Function benchmark_async_contention

tests/benchmark_baseline.rs:74–149

()

    /// Test lock contention with multiple async tasks
    #[tokio::test]
    async fn benchmark_async_contention() {
        eprintln!("\n=== Async Contention Benchmark ===");
        
        let db_handler = Arc::new(DbHandler::new(":memory:").unwrap());
        
        // Setup test data
        db_handler.execute("
            CREATE TABLE contention_test (
                id INTEGER PRIMARY KEY,
                value INTEGER
            )
        ").await.expect("Failed to create table");

        for i in 0..100 {
            db_handler.execute(&format!(
                "INSERT INTO contention_test (id, value) VALUES ({}, {})",
                i, i * 10
            )).await.expect("Failed to insert");
        }
        
        let task_counts = vec![1, 2, 4, 8];
        let iterations_per_task = 25;
        
        for task_count in task_counts {
            let start_time = Instant::now();
            let mut handles = Vec::new();
            
            for task_id in 0..task_count {
                let db_handler = db_handler.clone();
                let handle = tokio::spawn(async move {
                    let mut task_times = Vec::new();
                    
                    for i in 0..iterations_per_task {
                        let query_start = Instant::now();
                        let id = (task_id * iterations_per_task + i) % 100;
                        
                        let result = db_handler.query(
                            &format!("SELECT * FROM contention_test WHERE id = {}", id)
                        ).await.expect("Query failed");
                        
                        assert!(!result.rows.is_empty());
                        task_times.push(query_start.elapsed());
                    }
                    
                    task_times
                });
                
                handles.push(handle);
            }
            
            // Wait for all tasks
            let mut all_times = Vec::new();
            for handle in handles {
                let times = handle.await.expect("Task failed");
                all_times.extend(times);
            }
            
            let total_duration = start_time.elapsed();