metal-rust 1.0.0

Safe Rust interfaces for Apple Metal
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

//! Rust-native safe extensions for Metal 4 pipeline descriptors.

use crate::Error;

fn extents_to_ffi(
    value: &crate::metal::CheckedTensorExtents,
) -> Result<metal_rust_ffi::CheckedTensorExtents, Error> {
    metal_rust_ffi::CheckedTensorExtents::new(value.as_slice()).map_err(Error::from_ffi)
}

impl super::MeshRenderPipelineDescriptor {
    /// Returns required mesh threadgroup dimensions after availability checks.
    pub fn required_threads_per_mesh_threadgroup_safe(&self) -> Result<crate::metal::Size, Error> {
        self.inner
            .required_threads_per_mesh_threadgroup_safe()
            .map_err(Error::from_ffi)
    }

    /// Sets validated non-zero required mesh threadgroup dimensions.
    pub fn set_required_threads_per_mesh_threadgroup_safe(
        &self,
        value: crate::metal::Size,
    ) -> Result<(), Error> {
        self.inner
            .set_required_threads_per_mesh_threadgroup_safe(value)
            .map_err(Error::from_ffi)
    }

    /// Returns required object threadgroup dimensions after availability checks.
    pub fn required_threads_per_object_threadgroup_safe(
        &self,
    ) -> Result<crate::metal::Size, Error> {
        self.inner
            .required_threads_per_object_threadgroup_safe()
            .map_err(Error::from_ffi)
    }

    /// Sets validated non-zero required object threadgroup dimensions.
    pub fn set_required_threads_per_object_threadgroup_safe(
        &self,
        value: crate::metal::Size,
    ) -> Result<(), Error> {
        self.inner
            .set_required_threads_per_object_threadgroup_safe(value)
            .map_err(Error::from_ffi)
    }

    /// Resets the descriptor after checking runtime availability.
    pub fn reset_safe(&self) -> Result<(), Error> {
        self.inner.reset_safe().map_err(Error::from_ffi)
    }
}

impl super::MachineLearningPipelineDescriptor {
    /// Returns optional checked input dimensions for a non-negative buffer index.
    pub fn input_dimensions(
        &self,
        buffer_index: usize,
    ) -> Result<Option<crate::metal::CheckedTensorExtents>, Error> {
        self.inner
            .input_dimensions(buffer_index)
            .map_err(Error::from_ffi)?
            .map(|value| crate::metal::CheckedTensorExtents::new(value.as_slice()))
            .transpose()
    }

    /// Sets or clears checked input dimensions for a non-negative buffer index.
    pub fn set_input_dimensions(
        &self,
        buffer_index: usize,
        dimensions: Option<&crate::metal::CheckedTensorExtents>,
    ) -> Result<(), Error> {
        let dimensions = dimensions.map(extents_to_ffi).transpose()?;
        self.inner
            .set_input_dimensions(buffer_index, dimensions.as_ref())
            .map_err(Error::from_ffi)
    }

    /// Sets a contiguous range of checked input dimensions from a Rust slice.
    pub fn set_input_dimensions_slice(
        &self,
        start_index: usize,
        dimensions: &[crate::metal::CheckedTensorExtents],
    ) -> Result<(), Error> {
        let dimensions = dimensions
            .iter()
            .map(extents_to_ffi)
            .collect::<Result<Vec<_>, _>>()?;
        self.inner
            .set_input_dimensions_slice(start_index, &dimensions)
            .map_err(Error::from_ffi)
    }

    /// Resets the descriptor after checking runtime availability.
    pub fn reset_safe(&self) -> Result<(), Error> {
        self.inner.reset_safe().map_err(Error::from_ffi)
    }
}

impl super::MachineLearningPipelineReflection {
    /// Returns reflection bindings as an owned Rust vector.
    pub fn bindings_vec(&self) -> Result<Vec<crate::metal::Binding>, Error> {
        self.inner
            .bindings_vec()
            .map(|values| {
                values
                    .into_iter()
                    .map(crate::metal::Binding::from_ffi)
                    .collect()
            })
            .map_err(Error::from_ffi)
    }
}