Struct CompilerOptions 

pub struct CompilerOptions {
    pub workers: NonZeroUsize,
    pub target: Target,
    pub module_cache_capacity: usize,
    pub processor_mode: ProcessorMode,
    pub sanitizer: SanitizerOptions,
}

Compiler target and limits for concurrent workspaces and cached modules.

Fields

workers: NonZeroUsize

Maximum number of simultaneous compilations through this compiler.

target: Target

Architecture used by the Loom target profile and artifact cache.

module_cache_capacity: usize

Maximum retained source modules; zero disables module caching. Eviction chooses an arbitrary entry, not the least recently used module.

processor_mode: ProcessorMode

Workgroup scheduling policy for the selected AMDGPU target.

sanitizer: SanitizerOptions

Instrumentation included in pipeline, shared compiler, and artifact identities.

Implementations

impl CompilerOptions

pub fn for_target(target: &Target) -> Self

Default compiler limits for an explicit device target.

Examples found in repository

examples/patch_bench.rs (line 375)

fn main() -> Result<()> {
    let args: Vec<_> = std::env::args().collect();
    if args.len() < 3 || args.len() > 5 {
        return Err(hrx::Error::Message(
            "usage: patch_bench BASELINE_LIB CANDIDATE_LIB [pairs=30] [default|cu|wgp]".into(),
        ));
    }
    let pairs = args
        .get(3)
        .map(|s| s.parse::<usize>())
        .transpose()
        .map_err(|e| hrx::Error::Message(e.to_string()))?
        .unwrap_or(30);
    if pairs < 30 {
        return Err(hrx::Error::Message("at least 30 pairs are required".into()));
    }
    let mode = match args.get(4).map(String::as_str).unwrap_or("default") {
        "default" => ProcessorMode::Default,
        "cu" => ProcessorMode::ComputeUnit,
        "wgp" => ProcessorMode::WorkgroupProcessor,
        _ => {
            return Err(hrx::Error::Message(
                "mode must be default, cu or wgp".into(),
            ));
        }
    };
    let mut stream = Stream::open()?;
    let mut options = CompilerOptions::for_target(stream.target());
    options.processor_mode = mode;
    let compilers = [
        Compiler::with_options(Some(Path::new(&args[1])), options.clone())?,
        Compiler::with_options(Some(Path::new(&args[2])), options)?,
    ];
    for case in [
        attention(128, false),
        attention(512, false),
        gemm(false, false),
        gemm(true, false),
        gemm(false, true),
        gemm(true, true),
        conv(56, 64, 64),
        conv(14, 256, 256),
        conv(7, 512, 512),
    ] {
        let baseline = prepare(&mut stream, &compilers[0], &case, None)?;
        let candidate = prepare(
            &mut stream,
            &compilers[1],
            &case,
            Some(baseline.buffers.clone()),
        )?;
        let mut arms = [baseline, candidate];
        for arm in &mut arms {
            for _ in 0..5 {
                stream.launch(&mut arm.graph)?;
                stream.synchronize()?;
            }
            check(&mut stream, arm, &case)?;
        }
        let errors = [
            check(&mut stream, &arms[0], &case)?,
            check(&mut stream, &arms[1], &case)?,
        ];
        println!(
            "{}",
            serde_json::json!({"case":case.name,"mode":format!("{mode:?}"),"baseline":arms[0].identity,"candidate":arms[1].identity,"max_absolute_error":errors,"tolerance":case.tolerance,"replays":32})
        );
        for pair in 0..pairs {
            let mut ns = [0.0; 2];
            for index in if pair % 2 == 0 { [0, 1] } else { [1, 0] } {
                let start = Instant::now();
                stream.launch(&mut arms[index].graph)?;
                stream.synchronize()?;
                ns[index] = start.elapsed().as_secs_f64() * 1e9 / 32.0;
            }
            println!(
                "{}",
                serde_json::json!({"case":case.name,"pair":pair,"baseline_ns":ns[0],"candidate_ns":ns[1]})
            );
        }
        for arm in &mut arms {
            stream.launch(&mut arm.graph)?;
            stream.synchronize()?;
            check(&mut stream, arm, &case)?;
        }
    }
    Ok(())
}

pub fn for_stream(stream: &Stream) -> Self

Default compiler limits targeting the device behind stream.

Trait Implementations

impl Clone for CompilerOptions

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompilerOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CompilerOptions

fn default() -> Self

Returns the “default value” for a type.