Struct CompilationDescriptor 

pub struct CompilationDescriptor { /* private fields */ }

Safe owner for MPSGraphCompilationDescriptor.

Implementations

impl CompilationDescriptor

pub fn new() -> Option<Self>

Examples found in repository

examples/04_descriptor_compile.rs (line 17)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[4]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let output = graph
        .unary_arithmetic(UnaryArithmeticOp::Absolute, &input, Some("abs"))
        .expect("absolute");

    let descriptor = CompilationDescriptor::new().expect("compilation descriptor");
    descriptor
        .set_optimization_level(optimization::LEVEL1)
        .expect("set optimization level");
    descriptor
        .set_wait_for_compilation_completion(true)
        .expect("set wait");

    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[FeedDescription::new(&input, &[4], data_type::FLOAT32)],
            &[&output],
            Some(&descriptor),
        )
        .expect("compile");
    let input_type = ShapedType::new(Some(&[4]), data_type::FLOAT32).expect("shaped type");
    let output_types = executable
        .output_types(Some(&device), &[&input_type], Some(&descriptor))
        .expect("output types");

    println!("feed tensors: {}", executable.feed_tensors().len());
    println!("target tensors: {}", executable.target_tensors().len());
    println!("output type: {:?}", output_types[0].shape());
}

pub fn disable_type_inference(&self) -> Result<()>

pub fn optimization_level(&self) -> u64

pub fn set_optimization_level(&self, value: u64) -> Result<()>

Examples found in repository

examples/04_descriptor_compile.rs (line 19)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[4]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let output = graph
        .unary_arithmetic(UnaryArithmeticOp::Absolute, &input, Some("abs"))
        .expect("absolute");

    let descriptor = CompilationDescriptor::new().expect("compilation descriptor");
    descriptor
        .set_optimization_level(optimization::LEVEL1)
        .expect("set optimization level");
    descriptor
        .set_wait_for_compilation_completion(true)
        .expect("set wait");

    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[FeedDescription::new(&input, &[4], data_type::FLOAT32)],
            &[&output],
            Some(&descriptor),
        )
        .expect("compile");
    let input_type = ShapedType::new(Some(&[4]), data_type::FLOAT32).expect("shaped type");
    let output_types = executable
        .output_types(Some(&device), &[&input_type], Some(&descriptor))
        .expect("output types");

    println!("feed tensors: {}", executable.feed_tensors().len());
    println!("target tensors: {}", executable.target_tensors().len());
    println!("output type: {:?}", output_types[0].shape());
}

pub fn wait_for_compilation_completion(&self) -> bool

pub fn set_wait_for_compilation_completion(&self, value: bool) -> Result<()>

Examples found in repository

examples/04_descriptor_compile.rs (line 22)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[4]), data_type::FLOAT32, Some("input"))
        .expect("placeholder");
    let output = graph
        .unary_arithmetic(UnaryArithmeticOp::Absolute, &input, Some("abs"))
        .expect("absolute");

    let descriptor = CompilationDescriptor::new().expect("compilation descriptor");
    descriptor
        .set_optimization_level(optimization::LEVEL1)
        .expect("set optimization level");
    descriptor
        .set_wait_for_compilation_completion(true)
        .expect("set wait");

    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[FeedDescription::new(&input, &[4], data_type::FLOAT32)],
            &[&output],
            Some(&descriptor),
        )
        .expect("compile");
    let input_type = ShapedType::new(Some(&[4]), data_type::FLOAT32).expect("shaped type");
    let output_types = executable
        .output_types(Some(&device), &[&input_type], Some(&descriptor))
        .expect("output types");

    println!("feed tensors: {}", executable.feed_tensors().len());
    println!("target tensors: {}", executable.target_tensors().len());
    println!("output type: {:?}", output_types[0].shape());
}

pub fn optimization_profile(&self) -> u64

pub fn set_optimization_profile(&self, value: u64) -> Result<()>

pub fn reduced_precision_fast_math(&self) -> usize

pub fn set_reduced_precision_fast_math(&self, value: usize) -> Result<()>

Trait Implementations

impl Drop for CompilationDescriptor

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Send for CompilationDescriptor

impl Sync for CompilationDescriptor