cidre 0.12.0

Apple frameworks bindings for rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

mod core;
use crate::{arc, define_obj_type, ns, objc};

pub use self::core::PaddingMode;
pub use self::core::PaddingStyle;
pub use self::core::ReductionMode;
pub use self::core::ShapedType;
pub use self::core::TensorNamedDataLayout;
pub use self::core::Type as GraphType;

mod device;
pub use device::Device;
pub use device::DeviceType;

mod executable;
pub use executable::CompletionHandler as ExecutableCompletionHandler;
pub use executable::Executable;
pub use executable::ExecutionDesc as ExecutableExecutionDesc;
pub use executable::ScheduledHandler as ExecutableScheduledHandler;

mod tensor_data;
pub use tensor_data::TensorData;

mod tensor;
pub use tensor::Tensor;

mod operation;
pub use operation::Op;

mod memory_ops;
pub use memory_ops::VariableOp;

mod convolution_ops;
pub use convolution_ops::Conv2dOpDesc;

mod resize_ops;
pub use resize_ops::ResizeMode;
pub use resize_ops::ResizeNearestRoundingMode;

mod activation_ops;
mod arithmetic_ops;
mod gather_ops;
mod matrix_multiplication_ops;
mod normalization_ops;
mod shape_ops;

mod rnn_ops;
pub use rnn_ops::RnnActivation;
pub use rnn_ops::SingleGateRnnDesc;

/// Options to be utilized by the graph
#[doc(alias = "MPSGraphOptions")]
#[derive(Debug, Default, Eq, PartialEq, Copy, Clone)]
#[repr(u64)]
pub enum Opts {
    None = 0,

    /// Synchronize results using a blit encoder if on a GPU
    #[default]
    SynchronizeResults = 1,

    /// Prints more logging info
    Verbose = 2,
}

#[doc(alias = "MPSGraphOptimization")]
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
#[repr(u64)]
pub enum Optimization {
    /// Default optimizations
    Level0 = 0,

    /// Additional Optimizations
    Level1 = 1,
}

impl Default for Optimization {
    #[inline]
    fn default() -> Self {
        Self::Level0
    }
}

#[doc(alias = "MPSGraphOptimizationProfile")]
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
#[repr(u64)]
pub enum OptimizationProfile {
    /// Default, optimize for performance
    Performance = 0,

    /// Optimize for power efficiency
    Efficiency = 1,
}

impl Default for OptimizationProfile {
    #[inline]
    fn default() -> Self {
        Self::Performance
    }
}

/// Execution events that can be used with shared events
#[doc(alias = "MPSGraphExecutionStage")]
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
#[repr(u64)]
pub enum ExecutionStage {
    Completed = 0,
}

impl Default for ExecutionStage {
    #[inline]
    fn default() -> Self {
        Self::Completed
    }
}

/// A dictionary of tensors and correspondiing tensorData for them
#[doc(alias = "MPSGraphTensorDataDictionary")]
pub type TensorDataDictionary = ns::Dictionary<Tensor, TensorData>;

/// A dictionary of tensors and correspondiing shapes for them
#[doc(alias = "MPSGraphTensorShapedTypeDictionary")]
pub type TensorShapedTypeDictionary = ns::Dictionary<Tensor, ShapedType>;

define_obj_type!(pub Graph(ns::Id), MPS_GRAPH);

impl Graph {
    #[objc::msg_send(options)]
    pub fn opts(&self) -> Opts;

    #[objc::msg_send(setOptions:)]
    pub fn set_opts(&mut self, value: Opts);
}

#[link(name = "mpsg", kind = "static")]
unsafe extern "C" {
    static MPS_GRAPH: &'static objc::Class<Graph>;
}