Struct Executable 

pub struct Executable { /* private fields */ }

Safe owner for a compiled MPSGraphExecutable.

Implementations

impl Executable

pub fn options(&self) -> u64

Return the executable’s MPSGraphOptions bitmask.

pub fn set_options(&self, options: u64) -> Result<()>

Replace the executable’s options bitmask.

pub fn feed_tensors(&self) -> Vec<Tensor>

Return feed tensors if this executable was compiled from a graph.

Examples found in repository

examples/04_descriptor_compile.rs (line 38)

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 target_tensors(&self) -> Vec<Tensor>

Return target tensors if this executable was compiled from a graph.

Examples found in repository

examples/04_descriptor_compile.rs (line 39)

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 specialize( &self, device: Option<&MetalDevice>, input_types: &[&ShapedType], descriptor: Option<&CompilationDescriptor>, ) -> Result<()>

Specialize the executable for the provided input types.

pub fn output_types( &self, device: Option<&MetalDevice>, input_types: &[&ShapedType], descriptor: Option<&CompilationDescriptor>, ) -> Result<Vec<ShapedType>>

Query specialized output types for the provided input types.

Examples found in repository

examples/04_descriptor_compile.rs (line 35)

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 run_with_descriptor( &self, command_queue: &CommandQueue, inputs: &[&TensorData], results: Option<&[&TensorData]>, descriptor: Option<&ExecutableExecutionDescriptor>, ) -> Result<Vec<TensorData>>

Run the executable with an optional execution descriptor and optional preallocated results.

pub fn run_async_with_descriptor( &self, command_queue: &CommandQueue, inputs: &[&TensorData], results: Option<&[&TensorData]>, descriptor: Option<&ExecutableExecutionDescriptor>, ) -> Result<Vec<TensorData>>

Asynchronously run the executable with an optional execution descriptor.

pub fn serialize_package( &self, path: &str, descriptor: Option<&ExecutableSerializationDescriptor>, ) -> Result<()>

Serialize the executable to an .mpsgraphpackage path.

pub fn from_package( path: &str, descriptor: Option<&CompilationDescriptor>, ) -> Result<Self>

Load an executable from an existing .mpsgraphpackage.

impl Executable

pub const fn as_ptr(&self) -> *mut c_void

pub const fn output_count(&self) -> usize

pub fn run( &self, command_queue: &CommandQueue, inputs: &[&TensorData], ) -> Result<Vec<TensorData>>

Examples found in repository

examples/02_compile_matmul.rs (line 39)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");
    let graph = Graph::new().expect("failed to create MPSGraph");

    let left = graph
        .placeholder(Some(&[2, 3]), data_type::FLOAT32, Some("left"))
        .expect("failed to create left placeholder");
    let right = graph
        .placeholder(Some(&[3, 2]), data_type::FLOAT32, Some("right"))
        .expect("failed to create right placeholder");
    let output = graph
        .matrix_multiplication(&left, &right, Some("matmul"))
        .expect("failed to create matrix multiplication op");

    let executable = graph
        .compile(
            &device,
            &[
                FeedDescription::new(&left, &[2, 3], data_type::FLOAT32),
                FeedDescription::new(&right, &[3, 2], data_type::FLOAT32),
            ],
            &[&output],
        )
        .expect("failed to compile executable");

    let left_data = TensorData::from_f32_slice(&device, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3])
        .expect("failed to create left tensor data");
    let right_data =
        TensorData::from_f32_slice(&device, &[7.0, 8.0, 9.0, 10.0, 11.0, 12.0], &[3, 2])
            .expect("failed to create right tensor data");

    let results = executable
        .run(&queue, &[&left_data, &right_data])
        .expect("failed to run executable");
    let values = results[0].read_f32().expect("failed to read tensor output");
    let expected = [58.0_f32, 64.0, 139.0, 154.0];
    for (actual, expected_value) in values.iter().zip(expected) {
        assert!(
            (actual - expected_value).abs() < 1.0e-4,
            "unexpected matrix multiply result: {values:?}"
        );
    }

    println!("compile+matmul smoke passed: {values:?}");
}

examples/06_control_flow_call.rs (line 130)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let callee_graph = Graph::new().expect("callee graph");
    let callee_input = callee_graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("callee_input"))
        .expect("callee placeholder");
    let callee_output = callee_graph
        .addition(&callee_input, &callee_input, Some("callee_double"))
        .expect("callee output");
    let callee_executable = callee_graph
        .compile(
            &device,
            &[FeedDescription::new(&callee_input, &[2], data_type::FLOAT32)],
            &[&callee_output],
        )
        .expect("callee executable");

    let graph = Graph::new().expect("graph");
    let input = graph
        .placeholder(Some(&[2]), data_type::FLOAT32, Some("input"))
        .expect("input placeholder");
    let predicate = graph
        .placeholder(Some(&[]), data_type::BOOL, Some("predicate"))
        .expect("predicate placeholder");
    let bias = graph.constant_f32_slice(&[1.0, 1.0], &[2]).expect("bias constant");

    let output_type = ShapedType::new(Some(&[2]), data_type::FLOAT32).expect("output type");
    let call_results = graph
        .call("double", &[&input], &[&output_type], Some("call"))
        .expect("call op");
    let if_results = graph
        .if_then_else(
            &predicate,
            || vec![graph.addition(&input, &bias, None).expect("then add")],
            || vec![graph.subtraction(&input, &bias, None).expect("else sub")],
            Some("branch"),
        )
        .expect("if/then/else");

    let call_operation = call_results[0].operation().expect("call operation");
    let dependency = graph
        .control_dependency(&[&call_operation], || {
            vec![graph
                .unary_arithmetic(UnaryArithmeticOp::Identity, &call_results[0], None)
                .expect("identity")]
        }, Some("dependency"))
        .expect("control dependency");

    let number_of_iterations = graph
        .constant_scalar(4.0, data_type::INT32)
        .expect("iteration count");
    let zero = graph
        .constant_scalar(0.0, data_type::INT32)
        .expect("zero constant");
    let one = graph.constant_scalar(1.0, data_type::INT32).expect("one constant");
    let limit = graph
        .constant_scalar(3.0, data_type::INT32)
        .expect("limit constant");

    let for_results = graph
        .for_loop_iterations(&number_of_iterations, &[&zero], |_index, args| {
            vec![graph.addition(&args[0], &one, None).expect("for-loop add")]
        }, Some("for_loop"))
        .expect("for loop");
    let while_results = graph
        .while_loop(
            &[&zero],
            |inputs| {
                let condition = graph
                    .binary_arithmetic(BinaryArithmeticOp::LessThan, &inputs[0], &limit, None)
                    .expect("while predicate");
                let passthrough = graph
                    .unary_arithmetic(UnaryArithmeticOp::Identity, &inputs[0], None)
                    .expect("while passthrough");
                WhileBeforeResult {
                    predicate: condition,
                    results: vec![passthrough],
                }
            },
            |inputs| vec![graph.addition(&inputs[0], &one, None).expect("while add")],
            Some("while_loop"),
        )
        .expect("while loop");

    let compile_descriptor = CompilationDescriptor::new().expect("compile descriptor");
    compile_descriptor
        .set_callable("double", Some(&callee_executable))
        .expect("set callable");
    let executable = graph
        .compile_with_descriptor(
            Some(&device),
            &[
                FeedDescription::new(&input, &[2], data_type::FLOAT32),
                FeedDescription::new(&predicate, &[], data_type::BOOL),
            ],
            &[
                &call_results[0],
                &if_results[0],
                &dependency[0],
                &for_results[0],
                &while_results[0],
            ],
            Some(&compile_descriptor),
        )
        .expect("compile executable");

    let input_data = TensorData::from_f32_slice(&device, &[3.0, 4.0], &[2]).expect("input data");
    let predicate_data = TensorData::from_bytes(&device, &[1_u8], &[], data_type::BOOL)
        .expect("predicate data");
    let results = executable
        .run(&queue, &[&input_data, &predicate_data])
        .expect("run executable");

    println!("call output: {:?}", results[0].read_f32().expect("call output"));
    println!("if output: {:?}", results[1].read_f32().expect("if output"));
    println!("dependency output: {:?}", results[2].read_f32().expect("dependency output"));
    println!("for output: {:?}", read_i32(&results[3]));
    println!("while output: {:?}", read_i32(&results[4]));
}

Trait Implementations

impl Drop for Executable

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 Executable

impl Sync for Executable