Struct OperationMonitor 

pub struct OperationMonitor<'a> { /* private fields */ }

Operation monitor for tracking individual operations

Implementations

impl<'a> OperationMonitor<'a>

pub fn complete(self, itemsprocessed: usize) -> Result<()>

Complete the operation and record performance

Examples found in repository

examples/complete_integration.rs (line 149)

    fn demo_integrated_pipeline(&self) -> Result<()> {
        println!("📊 Demo 1: Integrated Text Processing Pipeline");
        println!("==============================================");

        let sample_documents = vec![
            "Artificial intelligence is revolutionizing the field of natural language processing.".to_string(),
            "Machine learning algorithms can now understand context and semantic meaning in text.".to_string(),
            "Deep neural networks have enabled breakthrough performance in text classification tasks.".to_string(),
            "SIMD optimizations allow for optimized string processing in modern computing systems.".to_string(),
            "Real-time adaptation ensures optimal performance across diverse text processing workloads.".to_string(),
        ];

        println!(
            "Processing {} documents through integrated pipeline...",
            sample_documents.len()
        );

        // Start performance monitoring
        let operation_monitor = self
            .performance_monitor
            .start_operation("integrated_pipeline")?;

        let start_time = Instant::now();

        // Process through Advanced coordinator
        let result = self.coordinator.advanced_processtext(&sample_documents)?;

        let processing_time = start_time.elapsed();

        // Complete monitoring
        operation_monitor.complete(sample_documents.len())?;

        println!("\n📈 Pipeline Results:");
        println!("  • Processing Time: {processing_time:?}");
        println!(
            "  • Throughput: {:.2} docs/sec",
            result.performance_metrics.throughput
        );
        println!(
            "  • Memory Efficiency: {:.1}%",
            result.performance_metrics.memory_efficiency * 100.0
        );
        println!(
            "  • Accuracy Estimate: {:.1}%",
            result.performance_metrics.accuracy_estimate * 100.0
        );

        println!("\n🔧 Applied Optimizations:");
        for optimization in &result.optimizations_applied {
            println!("  • {optimization}");
        }

        println!("\n🎯 Confidence Scores:");
        for (metric, score) in &result.confidence_scores {
            println!("  • {}: {:.1}%", metric, score * 100.0);
        }

        println!();
        Ok(())
    }

    /// Demonstrate performance-monitored SIMD operations
    fn demo_performance_monitored_simd(&self) -> Result<()> {
        println!("⚡ Demo 2: Performance-Monitored SIMD Operations");
        println!("===============================================");

        let testtexts = [
            "The quick brown fox jumps over the lazy dog".to_string(),
            "Pack my box with five dozen liquor jugs".to_string(),
            "How vexingly quick daft zebras jump!".to_string(),
            "Bright vixens jump; dozy fowl quack".to_string(),
        ];

        println!("Running SIMD-accelerated operations with performance monitoring...");

        // Start monitoring
        let operation_monitor = self
            .performance_monitor
            .start_operation("simd_operations")?;

        let start_time = Instant::now();

        // Optimized text processing
        let testtext_refs: Vec<&str> = testtexts.iter().map(|s| s.as_str()).collect();
        let processed_results = AdvancedSIMDTextProcessor::advanced_batch_process(&testtext_refs);

        // SIMD string operations
        let char_counts: Vec<usize> = testtexts
            .iter()
            .map(|text| SimdStringOps::count_chars(text, 'o'))
            .collect();

        // Optimized similarity matrix
        let similarity_matrix =
            AdvancedSIMDTextProcessor::advanced_similarity_matrix(&testtext_refs);

        let processing_time = start_time.elapsed();

        // Complete monitoring
        operation_monitor.complete(testtexts.len())?;

        println!("\n📊 SIMD Operation Results:");
        println!("  • Processing Time: {processing_time:?}");
        println!("  • Documents Processed: {}", processed_results.len());
        println!("  • Character Counts (letter 'o'): {char_counts:?}");
        println!(
            "  • Similarity Matrix Size: {}x{}",
            similarity_matrix.len(),
            similarity_matrix[0].len()
        );

        // Display similarity matrix
        println!("\n🔗 Text Similarity Matrix:");
        for (i, row) in similarity_matrix.iter().enumerate() {
            print!("  Row {i}: [");
            for (j, &similarity) in row.iter().enumerate() {
                if j > 0 {
                    print!(", ");
                }
                print!("{similarity:.3}");
            }
            println!("]");
        }

        // Show SIMD capabilities
        println!("\n⚙️  SIMD Capabilities:");
        println!("  • SIMD Available: {}", SimdStringOps::is_available());
        println!("  • String Processing: Optimized");
        println!("  • Pattern Matching: Optimized");
        println!("  • Similarity Computation: Vectorized");

        println!();
        Ok(())
    }

    /// Demonstrate adaptive streaming processing
    fn demo_adaptive_streaming(&self) -> Result<()> {
        println!("🌊 Demo 3: Adaptive Streaming Processing");
        println!("========================================");

        // Create large dataset simulation
        let largetexts: Vec<String> = (0..1000)
            .map(|i| format!("This is streaming document number {i} with various content lengths and different patterns of text processing requirements."))
            .collect();

        println!(
            "Processing {} documents through adaptive streaming...",
            largetexts.len()
        );

        // Start monitoring
        let operation_monitor = self
            .performance_monitor
            .start_operation("adaptive_streaming")?;

        let start_time = Instant::now();

        // Streaming processing with parallel optimization
        let streaming_processor = AdvancedStreamingProcessor::new(WordTokenizer::default())
            .with_parallelism(4, 1024 * 1024);

        // Simple token counting for demonstration
        let mut total_tokens = 0;
        let tokenizer = WordTokenizer::default();
        for text in &largetexts {
            if let Ok(tokens) = tokenizer.tokenize(text) {
                total_tokens += tokens.len();
            }
        }

        let processing_time = start_time.elapsed();

        // Complete monitoring
        operation_monitor.complete(largetexts.len())?;

        // Get memory stats instead of performance metrics
        let (current_mem, peak_mem) = streaming_processor.memory_stats();

        println!("\n📈 Streaming Processing Results:");
        println!("  • Processing Time: {processing_time:?}");
        println!("  • Documents Processed: {}", largetexts.len());
        println!("  • Total Tokens Extracted: {total_tokens}");
        println!("  • Current Memory Usage: {current_mem} bytes");
        println!("  • Peak Memory Usage: {peak_mem} bytes");
        println!(
            "  • Throughput: {:.2} docs/sec",
            largetexts.len() as f64 / processing_time.as_secs_f64()
        );

        println!("\n🔄 Advanced Features:");
        println!("  • Parallel Processing: Enabled");
        println!("  • Memory Monitoring: Active");
        println!("  • Advanced Tokenization: Optimized");

        println!();
        Ok(())
    }

    /// Demonstrate real-time optimization and adaptation
    fn demo_realtime_optimization(&self) -> Result<()> {
        println!("🎯 Demo 4: Real-time Optimization and Adaptation");
        println!("===============================================");

        // Simulate various workload patterns
        let workload_patterns = vec![
            ("Short Documents", generate_short_documents(50)),
            ("Medium Documents", generate_medium_documents(30)),
            ("Long Documents", generate_long_documents(20)),
            ("Mixed Workload", generate_mixed_workload(40)),
        ];

        for (pattern_name, documents) in workload_patterns {
            println!("\n🔄 Processing Pattern: {pattern_name}");
            println!("  • Document Count: {}", documents.len());

            // Start monitoring for this pattern
            let operation_monitor = self
                .performance_monitor
                .start_operation(&format!("pattern_{}", pattern_name.replace(' ', "_")))?;

            let start_time = Instant::now();

            // Process with adaptive optimization
            let result = self.coordinator.advanced_processtext(&documents)?;

            let processing_time = start_time.elapsed();

            // Complete monitoring
            operation_monitor.complete(documents.len())?;

            println!("  • Processing Time: {processing_time:?}");
            println!(
                "  • Throughput: {:.2} docs/sec",
                result.performance_metrics.throughput
            );
            println!(
                "  • Optimizations Applied: {}",
                result.optimizations_applied.len()
            );

            // Show adaptive responses
            if !result.optimizations_applied.is_empty() {
                println!("  • Adaptive Responses:");
                for opt in &result.optimizations_applied {
                    println!("    - {opt}");
                }
            }
        }

        // Get optimization recommendations
        let recommendations = self.performance_monitor.get_optimization_opportunities()?;

        println!("\n💡 Current Optimization Opportunities:");
        if recommendations.is_empty() {
            println!("  • No optimization opportunities identified");
            println!("  • System is operating at optimal performance");
        } else {
            for (i, rec) in recommendations.iter().enumerate() {
                println!("  {}. [{}] {}", i + 1, rec.category, rec.recommendation);
                println!(
                    "     Impact: {:.0}% | Complexity: {}/5",
                    rec.impact_estimate * 100.0,
                    rec.complexity
                );
            }
        }

        println!();
        Ok(())
    }