objc2_metal_performance_shaders_graph/generated/

MPSGraph.rs

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

use crate::*;

/// The options available to a graph.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphoptions?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct MPSGraphOptions(pub u64);
impl MPSGraphOptions {
    /// No Options.
    #[doc(alias = "MPSGraphOptionsNone")]
    pub const None: Self = Self(0);
    /// The graph synchronizes results to the CPU using a blit encoder if on a discrete GPU at the end of execution.
    #[doc(alias = "MPSGraphOptionsSynchronizeResults")]
    pub const SynchronizeResults: Self = Self(1);
    /// The framework prints more logging info.
    #[doc(alias = "MPSGraphOptionsVerbose")]
    pub const Verbose: Self = Self(2);
    /// The framework uses these options as default if not overriden.
    #[doc(alias = "MPSGraphOptionsDefault")]
    pub const Default: Self = Self(MPSGraphOptions::SynchronizeResults.0);
}

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

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

/// The optimization levels to trade compilation time for even more runtime performance by running more passes.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphoptimization?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct MPSGraphOptimization(pub u64);
impl MPSGraphOptimization {
    /// Graph performs core optimizations only.
    #[doc(alias = "MPSGraphOptimizationLevel0")]
    pub const Level0: Self = Self(0);
    /// Graph performs additional Optimizations, like using the placement pass to dispatch across different HW blocks like the NeuralEngine and CPU along with the GPU.
    #[doc(alias = "MPSGraphOptimizationLevel1")]
    pub const Level1: Self = Self(1);
}

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

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

/// The optimization profile used as a heuristic as the graph compiler optimizes the network.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphoptimizationprofile?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct MPSGraphOptimizationProfile(pub u64);
impl MPSGraphOptimizationProfile {
    /// Default, graph optimized for performance.
    #[doc(alias = "MPSGraphOptimizationProfilePerformance")]
    pub const Performance: Self = Self(0);
    /// Graph optimized for power efficiency.
    #[doc(alias = "MPSGraphOptimizationProfilePowerEfficiency")]
    pub const PowerEfficiency: Self = Self(1);
}

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

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

/// Execution events that can be used with shared events.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphexecutionstage?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct MPSGraphExecutionStage(pub u64);
impl MPSGraphExecutionStage {
    /// stage when execution of the graph completes.
    #[doc(alias = "MPSGraphExecutionStageCompleted")]
    pub const Completed: Self = Self(0);
}

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

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

/// MPSGraph could use these reduced precision paths to deliver faster math, but it is not guaranteed.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphreducedprecisionfastmath?language=objc)
// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct MPSGraphReducedPrecisionFastMath(pub NSUInteger);
bitflags::bitflags! {
    impl MPSGraphReducedPrecisionFastMath: NSUInteger {
/// Full precision math with maximum accuracy.
        #[doc(alias = "MPSGraphReducedPrecisionFastMathNone")]
        const None = 0;
/// Execute winograd transform intermediate as FP16.
        #[doc(alias = "MPSGraphReducedPrecisionFastMathAllowFP16Conv2DWinogradTransformIntermediate")]
        const AllowFP16Conv2DWinogradTransformIntermediate = 1<<1;
/// Curated list allowing intermediates for multi-pass GPU kernels to be FP16.
        #[doc(alias = "MPSGraphReducedPrecisionFastMathAllowFP16Intermediates")]
        const AllowFP16Intermediates = MPSGraphReducedPrecisionFastMath::AllowFP16Conv2DWinogradTransformIntermediate.0;
/// Default selection.
        #[doc(alias = "MPSGraphReducedPrecisionFastMathDefault")]
        const Default = MPSGraphReducedPrecisionFastMath::None.0;
    }
}

unsafe impl Encode for MPSGraphReducedPrecisionFastMath {
    const ENCODING: Encoding = NSUInteger::ENCODING;
}

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

/// A dictionary of tensors and corresponding tensor data.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphtensordatadictionary?language=objc)
#[cfg(all(
    feature = "MPSGraphCore",
    feature = "MPSGraphTensor",
    feature = "MPSGraphTensorData"
))]
pub type MPSGraphTensorDataDictionary = NSDictionary<MPSGraphTensor, MPSGraphTensorData>;

/// A dictionary of tensors and corresponding shapes for them.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphtensorshapedtypedictionary?language=objc)
#[cfg(all(feature = "MPSGraphCore", feature = "MPSGraphTensor"))]
pub type MPSGraphTensorShapedTypeDictionary = NSDictionary<MPSGraphTensor, MPSGraphShapedType>;

/// A notification that appears when graph execution finishes.
///
/// - Parameters:
/// - resultsDictionary: If no error, the results dictionary 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/mpsgraphcompletionhandler?language=objc)
#[cfg(all(
    feature = "MPSGraphCore",
    feature = "MPSGraphTensor",
    feature = "MPSGraphTensorData",
    feature = "block2"
))]
pub type MPSGraphCompletionHandler =
    *mut block2::DynBlock<dyn Fn(NonNull<MPSGraphTensorDataDictionary>, *mut NSError)>;

/// A notification that appears when graph execution schedules.
///
/// - Parameters:
/// - resultsDictionary: If no error, the results dictionary produced by the graph operation. If Graph has not yet allocated, the results 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/mpsgraphscheduledhandler?language=objc)
#[cfg(all(
    feature = "MPSGraphCore",
    feature = "MPSGraphTensor",
    feature = "MPSGraphTensorData",
    feature = "block2"
))]
pub type MPSGraphScheduledHandler =
    *mut block2::DynBlock<dyn Fn(NonNull<MPSGraphTensorDataDictionary>, *mut NSError)>;

/// A notification that appears when compilation finishes.
///
/// - Parameters:
/// - executable: If no error, the executable produced by the compilation.
/// - error: If an error occurs, more information might be found here.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphcompilationcompletionhandler?language=objc)
#[cfg(all(
    feature = "MPSGraphCore",
    feature = "MPSGraphExecutable",
    feature = "block2"
))]
pub type MPSGraphCompilationCompletionHandler =
    *mut block2::DynBlock<dyn Fn(NonNull<MPSGraphExecutable>, *mut NSError)>;

/// A dictionary of symbol names and the corresponding executables for them.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphcallablemap?language=objc)
#[cfg(all(feature = "MPSGraphCore", feature = "MPSGraphExecutable"))]
pub type MPSGraphCallableMap = NSDictionary<NSString, MPSGraphExecutable>;

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

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

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

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

#[cfg(feature = "MPSGraphCore")]
impl MPSGraphCompilationDescriptor {
    extern_methods!(
        /// Turns off type inference and relies on type inference during runtime.
        #[unsafe(method(disableTypeInference))]
        #[unsafe(method_family = none)]
        pub unsafe fn disableTypeInference(&self);

        /// The optimization level for the graph execution, default is MPSGraphOptimizationLevel1.
        #[unsafe(method(optimizationLevel))]
        #[unsafe(method_family = none)]
        pub unsafe fn optimizationLevel(&self) -> MPSGraphOptimization;

        /// Setter for [`optimizationLevel`][Self::optimizationLevel].
        #[unsafe(method(setOptimizationLevel:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setOptimizationLevel(&self, optimization_level: MPSGraphOptimization);

        /// Flag that makes the compile or specialize call blocking till the entire compilation is complete, defaults to NO.
        #[unsafe(method(waitForCompilationCompletion))]
        #[unsafe(method_family = none)]
        pub unsafe fn waitForCompilationCompletion(&self) -> bool;

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

        #[cfg(all(feature = "MPSGraphExecutable", feature = "block2"))]
        /// The handler that the graph calls when the compilation completes.
        ///
        /// 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(compilationCompletionHandler))]
        #[unsafe(method_family = none)]
        pub unsafe fn compilationCompletionHandler(&self) -> MPSGraphCompilationCompletionHandler;

        #[cfg(all(feature = "MPSGraphExecutable", feature = "block2"))]
        /// Setter for [`compilationCompletionHandler`][Self::compilationCompletionHandler].
        ///
        /// # Safety
        ///
        /// `compilation_completion_handler` must be a valid pointer.
        #[unsafe(method(setCompilationCompletionHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setCompilationCompletionHandler(
            &self,
            compilation_completion_handler: MPSGraphCompilationCompletionHandler,
        );

        #[cfg(feature = "dispatch2")]
        /// The dispatch queue used for the compilation.
        ///
        /// Default value is nil.
        #[unsafe(method(dispatchQueue))]
        #[unsafe(method_family = none)]
        pub unsafe fn dispatchQueue(&self) -> Retained<DispatchQueue>;

        #[cfg(feature = "dispatch2")]
        /// Setter for [`dispatchQueue`][Self::dispatchQueue].
        ///
        /// # Safety
        ///
        /// `dispatch_queue` possibly has additional threading requirements.
        #[unsafe(method(setDispatchQueue:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDispatchQueue(&self, dispatch_queue: &DispatchQueue);

        /// The optimization profile for the graph optimization.
        ///
        /// Default is MPSGraphOptimizationProfilePerformance.
        #[deprecated]
        #[unsafe(method(optimizationProfile))]
        #[unsafe(method_family = none)]
        pub unsafe fn optimizationProfile(&self) -> MPSGraphOptimizationProfile;

        /// Setter for [`optimizationProfile`][Self::optimizationProfile].
        #[deprecated]
        #[unsafe(method(setOptimizationProfile:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setOptimizationProfile(
            &self,
            optimization_profile: MPSGraphOptimizationProfile,
        );

        #[cfg(feature = "MPSGraphExecutable")]
        /// The dictionary used during runtime to lookup the ``MPSGraphExecutable`` which correspond to the ``symbolName``.
        #[unsafe(method(callables))]
        #[unsafe(method_family = none)]
        pub unsafe fn callables(&self) -> Option<Retained<MPSGraphCallableMap>>;

        #[cfg(feature = "MPSGraphExecutable")]
        /// Setter for [`callables`][Self::callables].
        #[unsafe(method(setCallables:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setCallables(&self, callables: Option<&MPSGraphCallableMap>);

        /// Across the executable allow reduced precision fast math optimizations.
        #[unsafe(method(reducedPrecisionFastMath))]
        #[unsafe(method_family = none)]
        pub unsafe fn reducedPrecisionFastMath(&self) -> MPSGraphReducedPrecisionFastMath;

        /// Setter for [`reducedPrecisionFastMath`][Self::reducedPrecisionFastMath].
        #[unsafe(method(setReducedPrecisionFastMath:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setReducedPrecisionFastMath(
            &self,
            reduced_precision_fast_math: MPSGraphReducedPrecisionFastMath,
        );
    );
}

/// Methods declared on superclass `NSObject`.
#[cfg(feature = "MPSGraphCore")]
impl MPSGraphCompilationDescriptor {
    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!(
    /// A class that consists of all the levers  to synchronize and schedule graph execution.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraphexecutiondescriptor?language=objc)
    #[unsafe(super(MPSGraphObject, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "MPSGraphCore")]
    pub struct MPSGraphExecutionDescriptor;
);

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

#[cfg(feature = "MPSGraphCore")]
impl MPSGraphExecutionDescriptor {
    extern_methods!(
        #[cfg(all(
            feature = "MPSGraphTensor",
            feature = "MPSGraphTensorData",
            feature = "block2"
        ))]
        /// The handler that graph calls when it schedules the execution.
        ///
        /// 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) -> MPSGraphScheduledHandler;

        #[cfg(all(
            feature = "MPSGraphTensor",
            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: MPSGraphScheduledHandler);

        #[cfg(all(
            feature = "MPSGraphTensor",
            feature = "MPSGraphTensorData",
            feature = "block2"
        ))]
        /// The handler that graph calls at the completion of the execution.
        ///
        /// 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) -> MPSGraphCompletionHandler;

        #[cfg(all(
            feature = "MPSGraphTensor",
            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: MPSGraphCompletionHandler);

        /// The flag that blocks the execution call until the entire execution is complete.
        ///
        /// Defaults to NO.
        #[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);

        /// The compilation descriptor for the graph.
        ///
        /// Default value is nil.
        #[unsafe(method(compilationDescriptor))]
        #[unsafe(method_family = none)]
        pub unsafe fn compilationDescriptor(
            &self,
        ) -> Option<Retained<MPSGraphCompilationDescriptor>>;

        /// Setter for [`compilationDescriptor`][Self::compilationDescriptor].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setCompilationDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setCompilationDescriptor(
            &self,
            compilation_descriptor: Option<&MPSGraphCompilationDescriptor>,
        );

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

        /// Executable 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 MPSGraphExecutionDescriptor {
    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 optimized representation of a compute graph of operations and tensors.
    ///
    /// An MPSGraph is a symbolic representation of operations to be utilized to execute compute graphs on a device.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/metalperformanceshadersgraph/mpsgraph?language=objc)
    #[unsafe(super(MPSGraphObject, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "MPSGraphCore")]
    pub struct MPSGraph;
);

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

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

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

        /// Creates a new graph to insert nodes in.
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;

        /// Initialize an MPSGraph to insert nodes in.
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[cfg(feature = "MPSGraphTensor")]
        /// Array of all the placeholder tensors.
        #[unsafe(method(placeholderTensors))]
        #[unsafe(method_family = none)]
        pub unsafe fn placeholderTensors(&self) -> Retained<NSArray<MPSGraphTensor>>;

        #[cfg(all(
            feature = "MPSGraphDevice",
            feature = "MPSGraphExecutable",
            feature = "MPSGraphOperation",
            feature = "MPSGraphTensor"
        ))]
        /// Compiles the graph for the given feeds to returns the target tensor values, ensuring all target operations would be executed.
        ///
        /// This call blocks until execution has completed. The compilation descriptor helps specialize the executable returned.
        ///
        /// - Parameters:
        /// - device: MPSGraph device to optimize for.
        /// - feeds: Feeds dictionary for the placeholder tensors.
        /// - targetTensors: Tensors for which the caller wishes MPSGraphTensorData to be returned.
        /// - targetOperations: Operations to be completed at the end of the run.
        /// - compilationDescriptor: compilation descriptor to set different compilation parameters.
        /// - Returns: A valid MPSGraphExecutable object
        #[unsafe(method(compileWithDevice:feeds:targetTensors:targetOperations:compilationDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn compileWithDevice_feeds_targetTensors_targetOperations_compilationDescriptor(
            &self,
            device: Option<&MPSGraphDevice>,
            feeds: &MPSGraphTensorShapedTypeDictionary,
            target_tensors: &NSArray<MPSGraphTensor>,
            target_operations: Option<&NSArray<MPSGraphOperation>>,
            compilation_descriptor: Option<&MPSGraphCompilationDescriptor>,
        ) -> Retained<MPSGraphExecutable>;

        #[cfg(all(
            feature = "MPSGraphOperation",
            feature = "MPSGraphTensor",
            feature = "MPSGraphTensorData"
        ))]
        /// Runs the graph for the given feeds and returns the target tensor values, ensuring all target operations also executed.
        ///
        /// This call blocks until execution has completed.
        ///
        /// - Parameters:
        /// - feeds: Feeds dictionary for the placeholder tensors.
        /// - targetTensors: Tensors for which the caller wishes MPSGraphTensorData to be returned.
        /// - targetOperations: Operations to be completed at the end of the run.
        /// - Returns: A valid MPSGraphTensor : MPSGraphTensorData dictionary with results synchronized to the CPU memory.
        #[unsafe(method(runWithFeeds:targetTensors:targetOperations:))]
        #[unsafe(method_family = none)]
        pub unsafe fn runWithFeeds_targetTensors_targetOperations(
            &self,
            feeds: &MPSGraphTensorDataDictionary,
            target_tensors: &NSArray<MPSGraphTensor>,
            target_operations: Option<&NSArray<MPSGraphOperation>>,
        ) -> Retained<MPSGraphTensorDataDictionary>;

        #[cfg(all(
            feature = "MPSGraphOperation",
            feature = "MPSGraphTensor",
            feature = "MPSGraphTensorData"
        ))]
        /// Runs the graph for the given feeds and returns the target tensor values, ensuring all target operations also executed.
        ///
        /// This call blocks until execution has completed.
        ///
        /// - Parameters:
        /// - commandQueue: CommandQueue passed to exectute the graph on.
        /// - feeds: Feeds dictionary for the placeholder tensors.
        /// - targetTensors: Tensors for which the caller wishes MPSGraphTensorData to be returned.
        /// - targetOperations: Operations to be completed at the end of the run.
        /// - Returns: A valid MPSGraphTensor : MPSGraphTensorData dictionary with results synchronized to the CPU memory.
        #[unsafe(method(runWithMTLCommandQueue:feeds:targetTensors:targetOperations:))]
        #[unsafe(method_family = none)]
        pub unsafe fn runWithMTLCommandQueue_feeds_targetTensors_targetOperations(
            &self,
            command_queue: &ProtocolObject<dyn MTLCommandQueue>,
            feeds: &MPSGraphTensorDataDictionary,
            target_tensors: &NSArray<MPSGraphTensor>,
            target_operations: Option<&NSArray<MPSGraphOperation>>,
        ) -> Retained<MPSGraphTensorDataDictionary>;

        #[cfg(all(
            feature = "MPSGraphOperation",
            feature = "MPSGraphTensor",
            feature = "MPSGraphTensorData"
        ))]
        /// Runs the graph for the given feeds and returns the target tensor values in the results dictionary provided by the user.
        ///
        /// It also ensures all target operations also executed. This call blocks until execution has completed.
        ///
        /// - Parameters:
        /// - commandQueue: CommandQueue passed to exectute the graph on.
        /// - feeds: Feeds dictionary for the placeholder tensors.
        /// - targetOperations: Operations to be completed at the end of the run.
        /// - resultsDictionary: MPSGraphTensors dictionary passed by user, these will be filled with graph output data.
        #[unsafe(method(runWithMTLCommandQueue:feeds:targetOperations:resultsDictionary:))]
        #[unsafe(method_family = none)]
        pub unsafe fn runWithMTLCommandQueue_feeds_targetOperations_resultsDictionary(
            &self,
            command_queue: &ProtocolObject<dyn MTLCommandQueue>,
            feeds: &MPSGraphTensorDataDictionary,
            target_operations: Option<&NSArray<MPSGraphOperation>>,
            results_dictionary: &MPSGraphTensorDataDictionary,
        );

        #[cfg(all(
            feature = "MPSGraphOperation",
            feature = "MPSGraphTensor",
            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 if a completionHandler is set.
        ///
        /// - Parameters:
        /// - feeds: Feeds dictionary for the placeholder tensors.
        /// - targetTensors: Tensors for which the caller wishes MPSGraphTensorData to be returned.
        /// - targetOperations: Operations to be completed at the end of the run.
        /// - executionDescriptor: ExecutionDescriptor to be passed in and used.
        /// - Returns: A valid MPSGraphTensor : MPSGraphTensorData dictionary with results synchronized to the CPU memory.
        #[unsafe(method(runAsyncWithFeeds:targetTensors:targetOperations:executionDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn runAsyncWithFeeds_targetTensors_targetOperations_executionDescriptor(
            &self,
            feeds: &MPSGraphTensorDataDictionary,
            target_tensors: &NSArray<MPSGraphTensor>,
            target_operations: Option<&NSArray<MPSGraphOperation>>,
            execution_descriptor: Option<&MPSGraphExecutionDescriptor>,
        ) -> Retained<MPSGraphTensorDataDictionary>;

        #[cfg(all(
            feature = "MPSGraphOperation",
            feature = "MPSGraphTensor",
            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 if a completionHandler is set.
        ///
        /// - Parameters:
        /// - commandQueue: CommandQueue passed to exectute the graph on.
        /// - feeds: Feeds dictionary for the placeholder tensors.
        /// - targetTensors: Tensors for which the caller wishes MPSGraphTensorData to be returned.
        /// - targetOperations: Operations to be completed at the end of the run.
        /// - executionDescriptor: ExecutionDescriptor to be passed in and used.
        /// - Returns: A valid MPSGraphTensor : MPSGraphTensorData dictionary with results synchronized to the CPU memory if MPSGraphOptionsSynchronizeResults set.
        #[unsafe(method(runAsyncWithMTLCommandQueue:feeds:targetTensors:targetOperations:executionDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn runAsyncWithMTLCommandQueue_feeds_targetTensors_targetOperations_executionDescriptor(
            &self,
            command_queue: &ProtocolObject<dyn MTLCommandQueue>,
            feeds: &MPSGraphTensorDataDictionary,
            target_tensors: &NSArray<MPSGraphTensor>,
            target_operations: Option<&NSArray<MPSGraphOperation>>,
            execution_descriptor: Option<&MPSGraphExecutionDescriptor>,
        ) -> Retained<MPSGraphTensorDataDictionary>;

        #[cfg(all(
            feature = "MPSGraphOperation",
            feature = "MPSGraphTensor",
            feature = "MPSGraphTensorData"
        ))]
        /// Encodes the graph for the given feeds to returns the target tensor values in the results dictionary provided by the user.
        ///
        /// It ensures all target operations also executed. This call is asynchronous and will return immediately if a completionHandler is set.
        ///
        /// - Parameters:
        /// - commandQueue: CommandQueue passed to exectute the graph on.
        /// - feeds: Feeds dictionary for the placeholder tensors.
        /// - targetOperations: Operations to be completed at the end of the run.
        /// - resultsDictionary: MPSGraphTensors dictionary passed by user, these will be filled with graph output data.
        /// - executionDescriptor: ExecutionDescriptor to be passed in and used.
        #[unsafe(method(runAsyncWithMTLCommandQueue:feeds:targetOperations:resultsDictionary:executionDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn runAsyncWithMTLCommandQueue_feeds_targetOperations_resultsDictionary_executionDescriptor(
            &self,
            command_queue: &ProtocolObject<dyn MTLCommandQueue>,
            feeds: &MPSGraphTensorDataDictionary,
            target_operations: Option<&NSArray<MPSGraphOperation>>,
            results_dictionary: &MPSGraphTensorDataDictionary,
            execution_descriptor: Option<&MPSGraphExecutionDescriptor>,
        );

        #[cfg(all(
            feature = "MPSGraphOperation",
            feature = "MPSGraphTensor",
            feature = "MPSGraphTensorData",
            feature = "objc2-metal-performance-shaders"
        ))]
        /// Encodes the graph for the given feeds to returns the target tensor values, ensuring all target operations also executed.
        ///
        /// This call is asynchronous and will return immediately if a completionHandler is set.
        ///
        /// - Parameters:
        /// - commandBuffer: commandBuffer passed to exectute the graph on, it is an MPSCommandBuffer, commitAndContinue might be called, please don't rely on underlying MTLCommandBuffer to remain uncommitted.
        /// - feeds: Feeds dictionary for the placeholder tensors.
        /// - targetTensors: Tensors for which the caller wishes MPSGraphTensorData to be returned.
        /// - targetOperations: Operations to be completed at the end of the run.
        /// - executionDescriptor: ExecutionDescriptor to be passed in and used.
        /// - Returns: A valid MPSGraphTensor : MPSGraphTensorData dictionary with results synchronized to the CPU memory if MPSGraphOptionsSynchronizeResults set.
        #[unsafe(method(encodeToCommandBuffer:feeds:targetTensors:targetOperations:executionDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn encodeToCommandBuffer_feeds_targetTensors_targetOperations_executionDescriptor(
            &self,
            command_buffer: &MPSCommandBuffer,
            feeds: &MPSGraphTensorDataDictionary,
            target_tensors: &NSArray<MPSGraphTensor>,
            target_operations: Option<&NSArray<MPSGraphOperation>>,
            execution_descriptor: Option<&MPSGraphExecutionDescriptor>,
        ) -> Retained<MPSGraphTensorDataDictionary>;

        #[cfg(all(
            feature = "MPSGraphOperation",
            feature = "MPSGraphTensor",
            feature = "MPSGraphTensorData",
            feature = "objc2-metal-performance-shaders"
        ))]
        /// Encodes the graph for the given feeds to returns the target tensor values in the results dictionary provided by the user.
        ///
        /// It ensures all target operations also executed. This call is asynchronous and will return immediately if a completionHandler is set.
        ///
        /// - Parameters:
        /// - commandBuffer: commandBuffer passed to execute the graph on, commitAndContinue might be called, please don't rely on underlying MTLCommandBuffer to remain uncommitted.
        /// - feeds: Feeds dictionary for the placeholder tensors.
        /// - targetOperations: Operations to be completed at the end of the run.
        /// - resultsDictionary: MPSGraphTensors dictionary passed by user, these will be filled with graph output data.
        /// - executionDescriptor: ExecutionDescriptor to be passed in and used.
        #[unsafe(method(encodeToCommandBuffer:feeds:targetOperations:resultsDictionary:executionDescriptor:))]
        #[unsafe(method_family = none)]
        pub unsafe fn encodeToCommandBuffer_feeds_targetOperations_resultsDictionary_executionDescriptor(
            &self,
            command_buffer: &MPSCommandBuffer,
            feeds: &MPSGraphTensorDataDictionary,
            target_operations: Option<&NSArray<MPSGraphOperation>>,
            results_dictionary: &MPSGraphTensorDataDictionary,
            execution_descriptor: Option<&MPSGraphExecutionDescriptor>,
        );
    );
}