Struct Runner 

pub struct Runner { /* private fields */ }

Configurable FEFF pipeline runner.

Implementations

impl Runner

pub fn new() -> Self

Construct a runner using process defaults.

Examples found in repository

examples/spectrum.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = std::env::args().skip(1);
    let input = args.next().ok_or("provide input and output paths")?;
    let output = args.next().ok_or("provide an output directory")?;
    let report = Runner::new().run_files(FileRunRequest::new(input, &output))?;
    let spectrum = io::xmu_dat::read_xmu_dat(std::path::Path::new(&output).join("xmu.dat"))?;
    println!(
        "{} completed stages; {} spectrum points",
        report.stages.len(),
        spectrum.photon_energy_ev.len()
    );
    if let Some(point) = spectrum.point(0) {
        println!(
            "First point: {} eV, μ={}",
            point.photon_energy.value(),
            point.mu
        );
    }
    Ok(())
}

examples/benchmark.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    if args.len() != 4 {
        return Err("expected INPUT OUTPUT MODE THREADS".into());
    }
    let input = PathBuf::from(&args[0]);
    let output = PathBuf::from(&args[1]);
    let threads: usize = args[3].parse()?;
    let mut runner = Runner::new();
    if let Some(n) = NonZeroUsize::new(threads) {
        runner = runner.with_threads(n);
    }
    let start = Instant::now();
    let (stages, bytes) = if args[2] == "memory" || args[2] == "typed" {
        if args[2] == "typed" {
            runner = runner.with_artifacts(ArtifactSelection::None);
        }
        let result = runner.run_in_memory(MemoryRunRequest::new(std::fs::read(input)?))?;
        (
            result.report.stages.len(),
            result
                .artifacts
                .iter()
                .map(|file| file.bytes.len() as u64)
                .sum::<u64>(),
        )
    } else {
        let policy = if args[2] == "recompute" {
            ExistingOutputPolicy::Recompute
        } else {
            ExistingOutputPolicy::ReuseValidated
        };
        let report = runner
            .run_files(FileRunRequest::new(input, &output).with_existing_output_policy(policy))?;
        let bytes = report
            .artifacts
            .iter()
            .map(|path| std::fs::metadata(output.join(path)).map(|m| m.len()))
            .collect::<Result<Vec<_>, _>>()?
            .into_iter()
            .sum::<u64>();
        (report.stages.len(), bytes)
    };
    println!(
        "{{\"seconds\":{},\"stages\":{},\"artifact_bytes\":{}}}",
        start.elapsed().as_secs_f64(),
        stages,
        bytes
    );
    Ok(())
}

pub fn with_threads(self, threads: NonZeroUsize) -> Self

Bound the calculation’s owned worker pool. ReFEFF faer calculations are serialized. WebAssembly runs on one thread regardless of this bound.

Examples found in repository

examples/benchmark.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    if args.len() != 4 {
        return Err("expected INPUT OUTPUT MODE THREADS".into());
    }
    let input = PathBuf::from(&args[0]);
    let output = PathBuf::from(&args[1]);
    let threads: usize = args[3].parse()?;
    let mut runner = Runner::new();
    if let Some(n) = NonZeroUsize::new(threads) {
        runner = runner.with_threads(n);
    }
    let start = Instant::now();
    let (stages, bytes) = if args[2] == "memory" || args[2] == "typed" {
        if args[2] == "typed" {
            runner = runner.with_artifacts(ArtifactSelection::None);
        }
        let result = runner.run_in_memory(MemoryRunRequest::new(std::fs::read(input)?))?;
        (
            result.report.stages.len(),
            result
                .artifacts
                .iter()
                .map(|file| file.bytes.len() as u64)
                .sum::<u64>(),
        )
    } else {
        let policy = if args[2] == "recompute" {
            ExistingOutputPolicy::Recompute
        } else {
            ExistingOutputPolicy::ReuseValidated
        };
        let report = runner
            .run_files(FileRunRequest::new(input, &output).with_existing_output_policy(policy))?;
        let bytes = report
            .artifacts
            .iter()
            .map(|path| std::fs::metadata(output.join(path)).map(|m| m.len()))
            .collect::<Result<Vec<_>, _>>()?
            .into_iter()
            .sum::<u64>();
        (report.stages.len(), bytes)
    };
    println!(
        "{{\"seconds\":{},\"stages\":{},\"artifact_bytes\":{}}}",
        start.elapsed().as_secs_f64(),
        stages,
        bytes
    );
    Ok(())
}

pub fn with_cancellation(self, cancellation: CancellationToken) -> Self

Use a caller-owned cooperative cancellation handle.

pub fn with_deadline(self, deadline: Instant) -> Self

Stop cooperatively once a monotonic deadline expires.

pub fn with_artifacts(self, selection: ArtifactSelection) -> Self

Select returned memory artifacts before reading their payloads.

Examples found in repository

examples/benchmark.rs (line 19)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    if args.len() != 4 {
        return Err("expected INPUT OUTPUT MODE THREADS".into());
    }
    let input = PathBuf::from(&args[0]);
    let output = PathBuf::from(&args[1]);
    let threads: usize = args[3].parse()?;
    let mut runner = Runner::new();
    if let Some(n) = NonZeroUsize::new(threads) {
        runner = runner.with_threads(n);
    }
    let start = Instant::now();
    let (stages, bytes) = if args[2] == "memory" || args[2] == "typed" {
        if args[2] == "typed" {
            runner = runner.with_artifacts(ArtifactSelection::None);
        }
        let result = runner.run_in_memory(MemoryRunRequest::new(std::fs::read(input)?))?;
        (
            result.report.stages.len(),
            result
                .artifacts
                .iter()
                .map(|file| file.bytes.len() as u64)
                .sum::<u64>(),
        )
    } else {
        let policy = if args[2] == "recompute" {
            ExistingOutputPolicy::Recompute
        } else {
            ExistingOutputPolicy::ReuseValidated
        };
        let report = runner
            .run_files(FileRunRequest::new(input, &output).with_existing_output_policy(policy))?;
        let bytes = report
            .artifacts
            .iter()
            .map(|path| std::fs::metadata(output.join(path)).map(|m| m.len()))
            .collect::<Result<Vec<_>, _>>()?
            .into_iter()
            .sum::<u64>();
        (report.stages.len(), bytes)
    };
    println!(
        "{{\"seconds\":{},\"stages\":{},\"artifact_bytes\":{}}}",
        start.elapsed().as_secs_f64(),
        stages,
        bytes
    );
    Ok(())
}

pub fn with_progress_sink(self, sink: Arc<dyn ProgressSink>) -> Self

Install a progress callback.

pub fn run_files(&self, request: FileRunRequest) -> Result<RunReport>

Execute the FEFF-compatible file pipeline.

Examples found in repository

examples/spectrum.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = std::env::args().skip(1);
    let input = args.next().ok_or("provide input and output paths")?;
    let output = args.next().ok_or("provide an output directory")?;
    let report = Runner::new().run_files(FileRunRequest::new(input, &output))?;
    let spectrum = io::xmu_dat::read_xmu_dat(std::path::Path::new(&output).join("xmu.dat"))?;
    println!(
        "{} completed stages; {} spectrum points",
        report.stages.len(),
        spectrum.photon_energy_ev.len()
    );
    if let Some(point) = spectrum.point(0) {
        println!(
            "First point: {} eV, μ={}",
            point.photon_energy.value(),
            point.mu
        );
    }
    Ok(())
}

examples/benchmark.rs (line 37)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    if args.len() != 4 {
        return Err("expected INPUT OUTPUT MODE THREADS".into());
    }
    let input = PathBuf::from(&args[0]);
    let output = PathBuf::from(&args[1]);
    let threads: usize = args[3].parse()?;
    let mut runner = Runner::new();
    if let Some(n) = NonZeroUsize::new(threads) {
        runner = runner.with_threads(n);
    }
    let start = Instant::now();
    let (stages, bytes) = if args[2] == "memory" || args[2] == "typed" {
        if args[2] == "typed" {
            runner = runner.with_artifacts(ArtifactSelection::None);
        }
        let result = runner.run_in_memory(MemoryRunRequest::new(std::fs::read(input)?))?;
        (
            result.report.stages.len(),
            result
                .artifacts
                .iter()
                .map(|file| file.bytes.len() as u64)
                .sum::<u64>(),
        )
    } else {
        let policy = if args[2] == "recompute" {
            ExistingOutputPolicy::Recompute
        } else {
            ExistingOutputPolicy::ReuseValidated
        };
        let report = runner
            .run_files(FileRunRequest::new(input, &output).with_existing_output_policy(policy))?;
        let bytes = report
            .artifacts
            .iter()
            .map(|path| std::fs::metadata(output.join(path)).map(|m| m.len()))
            .collect::<Result<Vec<_>, _>>()?
            .into_iter()
            .sum::<u64>();
        (report.stages.len(), bytes)
    };
    println!(
        "{{\"seconds\":{},\"stages\":{},\"artifact_bytes\":{}}}",
        start.elapsed().as_secs_f64(),
        stages,
        bytes
    );
    Ok(())
}

pub fn run_in_memory( &self, request: MemoryRunRequest, ) -> Result<MemoryRunResult>

Execute the same FEFF-compatible scheduler against an owned in-memory workspace.

A private temporary directory is used only as the compatibility transport for legacy FEFF file formats. Callers neither manage that directory nor receive ephemeral paths in the result.

Examples found in repository

examples/benchmark.rs (line 21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    if args.len() != 4 {
        return Err("expected INPUT OUTPUT MODE THREADS".into());
    }
    let input = PathBuf::from(&args[0]);
    let output = PathBuf::from(&args[1]);
    let threads: usize = args[3].parse()?;
    let mut runner = Runner::new();
    if let Some(n) = NonZeroUsize::new(threads) {
        runner = runner.with_threads(n);
    }
    let start = Instant::now();
    let (stages, bytes) = if args[2] == "memory" || args[2] == "typed" {
        if args[2] == "typed" {
            runner = runner.with_artifacts(ArtifactSelection::None);
        }
        let result = runner.run_in_memory(MemoryRunRequest::new(std::fs::read(input)?))?;
        (
            result.report.stages.len(),
            result
                .artifacts
                .iter()
                .map(|file| file.bytes.len() as u64)
                .sum::<u64>(),
        )
    } else {
        let policy = if args[2] == "recompute" {
            ExistingOutputPolicy::Recompute
        } else {
            ExistingOutputPolicy::ReuseValidated
        };
        let report = runner
            .run_files(FileRunRequest::new(input, &output).with_existing_output_policy(policy))?;
        let bytes = report
            .artifacts
            .iter()
            .map(|path| std::fs::metadata(output.join(path)).map(|m| m.len()))
            .collect::<Result<Vec<_>, _>>()?
            .into_iter()
            .sum::<u64>();
        (report.stages.len(), bytes)
    };
    println!(
        "{{\"seconds\":{},\"stages\":{},\"artifact_bytes\":{}}}",
        start.elapsed().as_secs_f64(),
        stages,
        bytes
    );
    Ok(())
}

Trait Implementations

impl Default for Runner

fn default() -> Runner

Returns the “default value” for a type.