Function run_parallel

crates/openquant/src/hpc_parallel.rs:172–218

(
    atoms: &[A],
    cfg: HpcParallelConfig,
    callback: F,
)

}

pub fn run_parallel<A, R, F, E>(
    atoms: &[A],
    cfg: HpcParallelConfig,
    callback: F,
) -> Result<ParallelRunReport<R>, HpcParallelError>
where
    A: Sync,
    R: Send,
    F: Fn(&[A]) -> Result<R, E> + Send + Sync,
    E: Display,
{
    validate_config(cfg)?;
    if atoms.is_empty() {
        return Ok(ParallelRunReport {
            outputs: Vec::new(),
            metrics: HpcParallelMetrics {
                atoms_total: 0,
                molecules_total: 0,
                runtime: Duration::ZERO,
                throughput_atoms_per_sec: 0.0,
                throughput_molecules_per_sec: 0.0,
                partition_imbalance_ratio: 0.0,
                progress: Vec::new(),
            },
        });
    }

    let worker_count = match cfg.mode {
        ExecutionMode::Serial => 1,
        ExecutionMode::Threaded { num_threads } => num_threads,
    };
    let target_molecules = worker_count.saturating_mul(cfg.mp_batches).max(1);
    let partitions = partition_atoms(atoms.len(), target_molecules, cfg.partition)?;
    let started = Instant::now();

    let (outputs, progress) = match cfg.mode {
        ExecutionMode::Serial => run_serial(atoms, &partitions, cfg.progress_every, &callback)?,
        ExecutionMode::Threaded { num_threads } => {
            run_threaded(atoms, &partitions, cfg.progress_every, num_threads, callback)?
        }
    };

    Ok(ParallelRunReport {
        outputs,
        metrics: build_metrics(atoms.len(), &partitions, started.elapsed(), progress),
    })
}

pub fn dispatch_async<A, R, F, E>(
    atoms: Vec<A>,