oneliner-macro 0.2.0

Macro and model codegen implementation for Oneliner
Documentation
use std::ffi::OsStr;
use std::fs;
use std::path::PathBuf;

use proc_macro2::Span;
use syn::Ident;

use super::discovery::parse_query_function;
use super::metadata::load_metadata;
use super::object_size::measure_object;
use super::toolchain::{run_converter, run_iree_compile};
use super::{ArtifactPaths, BindingArtifact, IreeArtifacts};
use crate::frontend::{Model, TensorInfo};
use crate::utils::{required_path_env, rust_ident};

pub(super) fn build(struct_ident: &Ident, model: Model) -> syn::Result<IreeArtifacts> {
    let Model {
        source_path: model_path,
        compile_input_path,
        ir_dump_stem,
        model_io,
    } = model;
    let struct_name = rust_ident(&struct_ident.to_string());
    let manifest_dir = required_path_env("CARGO_MANIFEST_DIR")?;
    let out_root = std::env::var_os("OUT_DIR")
        .map(PathBuf::from)
        .unwrap_or_else(|| manifest_dir.join("target").join("oneliner"));
    let model_stem = if model_path.is_dir() {
        model_path.file_name()
    } else {
        model_path.file_stem()
    }
    .and_then(OsStr::to_str)
    .map(rust_ident)
    .unwrap_or_else(|| struct_name.clone());
    let artifact_dir = out_root.join(format!("{struct_name}_iree_{model_stem}"));
    let ir_dump_dir = artifact_dir.join("iree-ir-dumps");
    fs::create_dir_all(&ir_dump_dir).map_err(|error| syn::Error::new(Span::call_site(), error))?;

    let vmfb_path = artifact_dir.join(format!("{model_stem}.vmfb"));
    let object_path = artifact_dir.join(format!("{model_stem}.o"));

    run_iree_compile(&compile_input_path, &vmfb_path, &object_path, &ir_dump_dir)?;
    let (query_fn, query_link_name) = parse_query_function(&object_path)?;
    let footprint = measure_object(&object_path)?;

    let ir_path = ir_dump_dir.join(format!("{ir_dump_stem}.10.executable-targets.mlir"));
    let flow_rs = artifact_dir.join(format!("{model_stem}.flow.rs"));
    let metadata_json = artifact_dir.join(format!("{model_stem}.flow.json"));
    run_converter(&ir_path, &flow_rs, &metadata_json)?;

    let metadata = load_metadata(&metadata_json)?;
    let input = metadata.input.ok_or_else(|| {
        syn::Error::new(
            Span::call_site(),
            "IREE metadata does not contain an input binding",
        )
    })?;
    validate_tensor_size("input", &input, &model_io.input)?;
    validate_tensor_size("output", &metadata.output, &model_io.output)?;

    Ok(IreeArtifacts {
        paths: ArtifactPaths {
            model: model_path,
            compile_input: compile_input_path,
            object: object_path,
            ir: ir_path,
            flow_rs,
            metadata_json,
        },
        query_fn,
        query_link_name,
        execute_fns: metadata.execute_fns,
        input,
        output: metadata.output,
        input_tensor: model_io.input,
        output_tensor: model_io.output,
        params_size: metadata.params_size,
        code_size: footprint.code_size,
        rodata_size: footprint.rodata_size,
        ram_size: metadata.ram_size,
    })
}

fn validate_tensor_size(
    label: &str,
    binding: &BindingArtifact,
    tensor: &TensorInfo,
) -> syn::Result<()> {
    let tensor_size = tensor
        .byte_len()
        .expect("frontend validated tensor byte size");
    if tensor_size != binding.size {
        return Err(syn::Error::new(
            Span::call_site(),
            format!(
                "{label} tensor {:?} with element width {} occupies {} bytes, but the IREE binding occupies {} bytes",
                tensor.shape,
                tensor.element_type.byte_width(),
                tensor_size,
                binding.size,
            ),
        ));
    }
    Ok(())
}