objc2_metal_performance_shaders_graph/generated/

MPSGraphExecutable.rs

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
use objc2_foundation::*;
use objc2_metal::*;
#[cfg(feature = "objc2-metal-performance-shaders")]
use objc2_metal_performance_shaders::*;

use crate::*;

/// A notification when graph executable execution finishes.
///
/// - Parameters:
/// - results: If no error, the results produced by the graph operation. If Graph hasn't yet allocated the results, this will be `NSNull`.
/// - error: If an error occurs, more information might be found here.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphexecutablecompletionhandler?language=objc)
#[cfg(all(
    feature = "MPSGraphCore",
    feature = "MPSGraphTensorData",
    feature = "block2"
))]
pub type MPSGraphExecutableCompletionHandler =
    *mut block2::DynBlock<dyn Fn(NonNull<NSArray<MPSGraphTensorData>>, *mut NSError)>;

/// A notification when graph executable execution schedules.
///
/// - Parameters:
/// - results: If no error, the results produced by the graph operation.
/// - error: If an error occurs, more information might be found here.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphexecutablescheduledhandler?language=objc)
#[cfg(all(
    feature = "MPSGraphCore",
    feature = "MPSGraphTensorData",
    feature = "block2"
))]
pub type MPSGraphExecutableScheduledHandler =
    *mut block2::DynBlock<dyn Fn(NonNull<NSArray<MPSGraphTensorData>>, *mut NSError)>;

extern_class!(
    /// A class that consists of all the levers  to synchronize and schedule executable execution.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphexecutableexecutiondescriptor?language=objc)
    #[unsafe(super(MPSGraphObject, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "MPSGraphCore")]
    pub struct MPSGraphExecutableExecutionDescriptor;
);

#[cfg(feature = "MPSGraphCore")]
extern_conformance!(
    unsafe impl NSCopying for MPSGraphExecutableExecutionDescriptor {}
);

#[cfg(feature = "MPSGraphCore")]
unsafe impl CopyingHelper for MPSGraphExecutableExecutionDescriptor {
    type Result = Self;
}

#[cfg(feature = "MPSGraphCore")]
extern_conformance!(
    unsafe impl NSObjectProtocol for MPSGraphExecutableExecutionDescriptor {}
);

#[cfg(feature = "MPSGraphCore")]
impl MPSGraphExecutableExecutionDescriptor {
    extern_methods!(
        #[cfg(all(feature = "MPSGraphTensorData", feature = "block2"))]
        /// A notification that appears when graph-executable execution is scheduled.
        ///
        /// Default value is nil.
        ///
        /// # Safety
        ///
        /// - The returned block's argument 1 must be a valid pointer.
        /// - The returned block's argument 2 must be a valid pointer or null.
        #[unsafe(method(scheduledHandler))]
        #[unsafe(method_family = none)]
        pub unsafe fn scheduledHandler(&self) -> MPSGraphExecutableScheduledHandler;

        #[cfg(all(feature = "MPSGraphTensorData", feature = "block2"))]
        /// Setter for [`scheduledHandler`][Self::scheduledHandler].
        ///
        /// # Safety
        ///
        /// `scheduled_handler` must be a valid pointer.
        #[unsafe(method(setScheduledHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setScheduledHandler(
            &self,
            scheduled_handler: MPSGraphExecutableScheduledHandler,
        );

        #[cfg(all(feature = "MPSGraphTensorData", feature = "block2"))]
        /// A notification that appears when graph-executable execution is finished.
        ///
        /// Default value is nil.
        ///
        /// # Safety
        ///
        /// - The returned block's argument 1 must be a valid pointer.
        /// - The returned block's argument 2 must be a valid pointer or null.
        #[unsafe(method(completionHandler))]
        #[unsafe(method_family = none)]
        pub unsafe fn completionHandler(&self) -> MPSGraphExecutableCompletionHandler;

        #[cfg(all(feature = "MPSGraphTensorData", feature = "block2"))]
        /// Setter for [`completionHandler`][Self::completionHandler].
        ///
        /// # Safety
        ///
        /// `completion_handler` must be a valid pointer.
        #[unsafe(method(setCompletionHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setCompletionHandler(
            &self,
            completion_handler: MPSGraphExecutableCompletionHandler,
        );

        /// Flag for the graph executable to wait till the execution has completed.
        ///
        /// Default value is false.
        #[unsafe(method(waitUntilCompleted))]
        #[unsafe(method_family = none)]
        pub unsafe fn waitUntilCompleted(&self) -> bool;

        /// Setter for [`waitUntilCompleted`][Self::waitUntilCompleted].
        #[unsafe(method(setWaitUntilCompleted:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setWaitUntilCompleted(&self, wait_until_completed: bool);

        /// Waits on these shared events before scheduling execution on the HW.
        ///
        /// This does not include encoding which can still continue.
        ///
        /// - Parameters:
        /// - event: Shared event to wait on.
        /// - value: Value for shared event to wait on.
        #[unsafe(method(waitForEvent:value:))]
        #[unsafe(method_family = none)]
        pub unsafe fn waitForEvent_value(
            &self,
            event: &ProtocolObject<dyn MTLSharedEvent>,
            value: u64,
        );

        #[cfg(feature = "MPSGraph")]
        /// Signals these shared events at execution stage and immediately proceeds.
        ///
        /// - Parameters:
        /// - event: Shared event to signal.
        /// - executionStage: Execution stage to signal event at.
        /// - value: Value for shared event to wait on.
        #[unsafe(method(signalEvent:atExecutionEvent:value:))]
        #[unsafe(method_family = none)]
        pub unsafe fn signalEvent_atExecutionEvent_value(
            &self,
            event: &ProtocolObject<dyn MTLSharedEvent>,
            execution_stage: MPSGraphExecutionStage,
            value: u64,
        );
    );
}

/// Methods declared on superclass `NSObject`.
#[cfg(feature = "MPSGraphCore")]
impl MPSGraphExecutableExecutionDescriptor {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

/// The options available to a graph.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphdeploymentplatform?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct MPSGraphDeploymentPlatform(pub u64);
impl MPSGraphDeploymentPlatform {
    /// Deployment platofmr for macOS.
    #[doc(alias = "MPSGraphDeploymentPlatformMacOS")]
    pub const MacOS: Self = Self(0);
    /// Deployment target for iOS.
    #[doc(alias = "MPSGraphDeploymentPlatformIOS")]
    pub const IOS: Self = Self(1);
    /// Deployment target for tvOS.
    #[doc(alias = "MPSGraphDeploymentPlatformTvOS")]
    pub const TvOS: Self = Self(2);
    /// Deployment target for visionOS.
    #[doc(alias = "MPSGraphDeploymentPlatformVisionOS")]
    pub const VisionOS: Self = Self(3);
}

unsafe impl Encode for MPSGraphDeploymentPlatform {
    const ENCODING: Encoding = u64::ENCODING;
}

unsafe impl RefEncode for MPSGraphDeploymentPlatform {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

extern_class!(
    /// A class that consists of all the levers  to serialize an executable.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphexecutableserializationdescriptor?language=objc)
    #[unsafe(super(MPSGraphObject, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "MPSGraphCore")]
    pub struct MPSGraphExecutableSerializationDescriptor;
);

#[cfg(feature = "MPSGraphCore")]
extern_conformance!(
    unsafe impl NSObjectProtocol for MPSGraphExecutableSerializationDescriptor {}
);

#[cfg(feature = "MPSGraphCore")]
impl MPSGraphExecutableSerializationDescriptor {
    extern_methods!(
        /// Flag to append to an existing .mpsgraphpackage if found at provided url.
        ///
        /// If false, the exisiting .mpsgraphpackage will be overwritten.
        #[unsafe(method(append))]
        #[unsafe(method_family = none)]
        pub unsafe fn append(&self) -> bool;

        /// Setter for [`append`][Self::append].
        #[unsafe(method(setAppend:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setAppend(&self, append: bool);

        /// The deployment platform used to serialize the executable.
        ///
        /// Defaults to the current platform.
        #[unsafe(method(deploymentPlatform))]
        #[unsafe(method_family = none)]
        pub unsafe fn deploymentPlatform(&self) -> MPSGraphDeploymentPlatform;

        /// Setter for [`deploymentPlatform`][Self::deploymentPlatform].
        #[unsafe(method(setDeploymentPlatform:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDeploymentPlatform(&self, deployment_platform: MPSGraphDeploymentPlatform);

        /// The minimum deployment target to serialize the executable.
        ///
        /// If not set, the package created will target the latest version of the `deploymentPlatform` set.
        #[unsafe(method(minimumDeploymentTarget))]
        #[unsafe(method_family = none)]
        pub unsafe fn minimumDeploymentTarget(&self) -> Retained<NSString>;

        /// Setter for [`minimumDeploymentTarget`][Self::minimumDeploymentTarget].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setMinimumDeploymentTarget:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setMinimumDeploymentTarget(&self, minimum_deployment_target: &NSString);
    );
}

/// Methods declared on superclass `NSObject`.
#[cfg(feature = "MPSGraphCore")]
impl MPSGraphExecutableSerializationDescriptor {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// The compiled representation of a compute graph executable.
    ///
    /// An `MPSGraphExecutable` is a compiled graph for specific feeds for specific target tensors and target operations.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphexecutable?language=objc)
    #[unsafe(super(MPSGraphObject, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "MPSGraphCore")]
    pub struct MPSGraphExecutable;
);

#[cfg(feature = "MPSGraphCore")]
unsafe impl Send for MPSGraphExecutable {}

#[cfg(feature = "MPSGraphCore")]
unsafe impl Sync for MPSGraphExecutable {}

#[cfg(feature = "MPSGraphCore")]
extern_conformance!(
    unsafe impl NSObjectProtocol for MPSGraphExecutable {}
);

#[cfg(feature = "MPSGraphCore")]
impl MPSGraphExecutable {
    extern_methods!(
        #[cfg(feature = "MPSGraph")]
        /// Options for the graph executable.
        ///
        /// Default value is `MPSGraphOptionsDefault`.
        #[unsafe(method(options))]
        #[unsafe(method_family = none)]
        pub unsafe fn options(&self) -> MPSGraphOptions;

        #[cfg(feature = "MPSGraph")]
        /// Setter for [`options`][Self::options].
        #[unsafe(method(setOptions:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setOptions(&self, options: MPSGraphOptions);

        #[cfg(feature = "MPSGraphTensor")]
        /// Tensors fed to the graph, can be used to order the inputs when executable is created with a graph.
        #[unsafe(method(feedTensors))]
        #[unsafe(method_family = none)]
        pub unsafe fn feedTensors(&self) -> Option<Retained<NSArray<MPSGraphTensor>>>;

        #[cfg(feature = "MPSGraphTensor")]
        /// Tensors targeted by the graph, can be used to order the outputs when executable was created with a graph.
        #[unsafe(method(targetTensors))]
        #[unsafe(method_family = none)]
        pub unsafe fn targetTensors(&self) -> Option<Retained<NSArray<MPSGraphTensor>>>;

        #[cfg(all(feature = "MPSGraph", feature = "MPSGraphDevice"))]
        /// Specialize the executable and optimize it.
        ///
        /// Use this method to choose when specialization happens, else it occurs at encode time automatically.
        ///
        /// - Parameters:
        /// - device:Ooptional MPSGraph device to compile with.
        /// - inputTypes: Input types expected to be passed to the executable.
        /// - compilationDescriptor: Compilation descriptor to be used to specialize, since the executable was created with a compilationDescriptor already this one overrides those settings to the extent it can.
        #[unsafe(method(specializeWithDevice:inputTypes:compilationDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn specializeWithDevice_inputTypes_compilationDescriptor(
            &self,
            device: Option<&MPSGraphDevice>,
            input_types: &NSArray<MPSGraphType>,
            compilation_descriptor: Option<&MPSGraphCompilationDescriptor>,
        );

        #[cfg(all(feature = "MPSGraph", feature = "MPSGraphDevice"))]
        /// Get output shapes for a specialized executable.
        ///
        /// In case specialization has not been done yet then calling this function will specialize for the given input shapes.
        ///
        /// - Parameters:
        /// - device: Optional MPSGraph device to compile with
        /// - inputTypes: Input types expected to be passed to the executable.
        /// - compilationDescriptor: CompilationDescriptor to be used to specialize, since the executable was created with a compilationDescriptor already this one overrides those settings to the extent it can.
        #[unsafe(method(getOutputTypesWithDevice:inputTypes:compilationDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn getOutputTypesWithDevice_inputTypes_compilationDescriptor(
            &self,
            device: Option<&MPSGraphDevice>,
            input_types: &NSArray<MPSGraphType>,
            compilation_descriptor: Option<&MPSGraphCompilationDescriptor>,
        ) -> Option<Retained<NSArray<MPSGraphShapedType>>>;

        #[cfg(feature = "MPSGraphTensorData")]
        /// Runs the graph for the given feeds and returns the target tensor values, ensuring all target operations also executed.
        ///
        /// This call is synchronous and will return on completion of execution.
        ///
        /// - Parameters:
        /// - commandQueue: CommandQueue passed to exectute the graph on.
        /// - inputsArray: Feeds tensorData for the placeholder tensors, same order as arguments of main function.
        /// - resultsArray: Results tensorData for which the caller wishes MPSGraphTensorData to be returned.
        /// - Returns: A valid MPSGraphTensorData array with results synchronized to the CPU memory if MPSGraphOptionsSynchronizeResults set.
        #[unsafe(method(runWithMTLCommandQueue:inputsArray:resultsArray:executionDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn runWithMTLCommandQueue_inputsArray_resultsArray_executionDescriptor(
            &self,
            command_queue: &ProtocolObject<dyn MTLCommandQueue>,
            inputs_array: &NSArray<MPSGraphTensorData>,
            results_array: Option<&NSArray<MPSGraphTensorData>>,
            execution_descriptor: Option<&MPSGraphExecutableExecutionDescriptor>,
        ) -> Retained<NSArray<MPSGraphTensorData>>;

        #[cfg(feature = "MPSGraphTensorData")]
        /// Runs the graph for the given feeds and returns the target tensor values, ensuring all target operations also executed.
        /// This call is asynchronous and will return immediately.
        ///
        /// - Parameters:
        /// - commandQueue: CommandQueue passed to exectute the graph on.
        /// - inputsArray: Feeds tensorData for the placeholder tensors, same order as arguments of main function.
        /// - resultsArray: Tensors for which the caller wishes MPSGraphTensorData to be returned.
        /// - executionDescriptor: ExecutionDescriptor to be passed in and used.
        /// - Returns: A valid MPSGraphTensorData array with results synchronized to the CPU memory if MPSGraphOptionsSynchronizeResults set.
        #[unsafe(method(runAsyncWithMTLCommandQueue:inputsArray:resultsArray:executionDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn runAsyncWithMTLCommandQueue_inputsArray_resultsArray_executionDescriptor(
            &self,
            command_queue: &ProtocolObject<dyn MTLCommandQueue>,
            inputs_array: &NSArray<MPSGraphTensorData>,
            results_array: Option<&NSArray<MPSGraphTensorData>>,
            execution_descriptor: Option<&MPSGraphExecutableExecutionDescriptor>,
        ) -> Retained<NSArray<MPSGraphTensorData>>;

        #[cfg(all(
            feature = "MPSGraphTensorData",
            feature = "objc2-metal-performance-shaders"
        ))]
        /// Runs the graph for the given feeds and returns the target tensor values, ensuring all target operations also executed.
        /// This call is asynchronous and will return immediately after finishing encoding.
        ///
        /// - Parameters:
        /// - commandBuffer: CommandBuffer passed to exectute the graph on, commitAndContinue might be called, please don't rely on underlying MTLCommandBuffer to remain uncommitted
        /// - inputsArray: Feeds tensorData for the placeholder tensors, same order as arguments of main function
        /// - resultsArray: Tensors for which the caller wishes MPSGraphTensorData to be returned
        /// - executionDescriptor: ExecutionDescriptor to be passed in and used,
        /// - Returns: A valid MPSGraphTensorData array with results synchronized to the CPU memory if MPSGraphOptionsSynchronizeResults set.
        #[unsafe(method(encodeToCommandBuffer:inputsArray:resultsArray:executionDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn encodeToCommandBuffer_inputsArray_resultsArray_executionDescriptor(
            &self,
            command_buffer: &MPSCommandBuffer,
            inputs_array: &NSArray<MPSGraphTensorData>,
            results_array: Option<&NSArray<MPSGraphTensorData>>,
            execution_descriptor: Option<&MPSGraphExecutableExecutionDescriptor>,
        ) -> Retained<NSArray<MPSGraphTensorData>>;

        /// Serialize the MPSGraph executable at the provided url.
        ///
        /// - Parameters:
        /// - url: The URL where to serialize the MPSGraph executable.
        /// - descriptor: The descriptor to be used to serialize the graph.
        #[unsafe(method(serializeToMPSGraphPackageAtURL:descriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn serializeToMPSGraphPackageAtURL_descriptor(
            &self,
            url: &NSURL,
            descriptor: Option<&MPSGraphExecutableSerializationDescriptor>,
        );

        #[cfg(feature = "MPSGraph")]
        /// Initialize the executable with the Metal Performance Shaders Graph package at the provided URL.
        ///
        /// - Parameters:
        /// - mpsgraphPackageURL: The URL where to read the serialized MPSGraphExecutable.
        /// - compilationDescriptor: Compilation descriptor to be used to specialize, since the executable was created with a compilationDescriptor already this one overrides those settings to the extent it can.
        #[unsafe(method(initWithMPSGraphPackageAtURL:compilationDescriptor:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithMPSGraphPackageAtURL_compilationDescriptor(
            this: Allocated<Self>,
            mpsgraph_package_url: &NSURL,
            compilation_descriptor: Option<&MPSGraphCompilationDescriptor>,
        ) -> Retained<Self>;

        #[cfg(feature = "MPSGraph")]
        /// Initialize the executable with the Core ML model package at the provided URL.
        ///
        /// - Parameters:
        /// - coreMLPackageURL: The URL where to read the Core ML model package.
        /// - compilationDescriptor: Compilation descriptor to be used to specialize, since the executable was created with a compilationDescriptor already this one overrides those settings to the extent it can.
        #[unsafe(method(initWithCoreMLPackageAtURL:compilationDescriptor:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithCoreMLPackageAtURL_compilationDescriptor(
            this: Allocated<Self>,
            core_ml_package_url: &NSURL,
            compilation_descriptor: Option<&MPSGraphCompilationDescriptor>,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
#[cfg(feature = "MPSGraphCore")]
impl MPSGraphExecutable {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}