Function parallel_record_files

atomic-repository/src/parallel_record/mod.rs:434–492

Process files in parallel using rayon, returning per-file results. This is the core of the parallel recording pipeline (Phase 2). It takes a list of [`FileRecordInput`] descriptors (built during the sequential pre-pass) and processes each file independently on a rayon worker thread. # Automatic Sequential Fallback If `options.should_parallelize(inputs.len())` returns `false` (e.g., fewer than 4

(
    inputs: &[FileRecordInput],
    options: &ParallelRecordOptions,
)

/// than 4 files), processing falls back to sequential iteration to avoid
/// rayon overhead.
pub fn parallel_record_files(
    inputs: &[FileRecordInput],
    options: &ParallelRecordOptions,
) -> (Vec<Result<FileRecordOutput, String>>, ParallelRecordStats) {
    use rayon::prelude::*;

    let start = Instant::now();
    let use_parallel = options.should_parallelize(inputs.len());

    let results: Vec<Result<FileRecordOutput, String>> = if use_parallel {
        inputs
            .par_iter()
            .map(|input| process_single_file(input, &options.core_options))
            .collect()
    } else {
        inputs
            .iter()
            .map(|input| process_single_file(input, &options.core_options))
            .collect()
    };

    let wall_time_ms = start.elapsed().as_millis() as u64;

    // Compute aggregate stats
    let mut stats = ParallelRecordStats {
        files_processed: inputs.len(),
        used_parallel: use_parallel,
        wall_time_ms,
        ..Default::default()
    };

    let mut cpu_time_ms = 0u64;
    for result in &results {
        match result {
            Ok(output) => {
                cpu_time_ms += output.stats.processing_time_ms;
                if output.skipped {
                    stats.files_skipped += 1;
                } else if output.recorded.is_some() {
                    stats.files_recorded += 1;
                } else {
                    stats.files_skipped += 1;
                }
            }
            Err(_) => {
                stats.files_errored += 1;
            }
        }
    }

    stats.cpu_time_ms = cpu_time_ms;
    stats.effective_parallelism = if wall_time_ms > 0 {
        cpu_time_ms as f64 / wall_time_ms as f64
    } else {
        1.0
    };

    (results, stats)