apple-mpsgraph 0.2.7

Safe Rust bindings for Apple's MetalPerformanceShadersGraph framework on macOS, backed by a Swift bridge
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

import Foundation
import MetalPerformanceShadersGraph

@_cdecl("mpsgraph_shaped_type_new")
public func mpsgraph_shaped_type_new(
    _ shape: UnsafePointer<Int>?,
    _ shapeLen: Int,
    _ dataTypeRaw: UInt32
) -> UnsafeMutableRawPointer? {
    guard let dataType = mpsgraph_data_type(dataTypeRaw) else {
        return nil
    }
    return mpsgraph_retain(MPSGraphShapedType(shape: mpsgraph_optional_signed_shape(shape, shapeLen), dataType: dataType))
}

@_cdecl("mpsgraph_shaped_type_has_shape")
public func mpsgraph_shaped_type_has_shape(_ handle: UnsafeMutableRawPointer?) -> Bool {
    guard let handle else {
        return false
    }
    let shapedType: MPSGraphShapedType = mpsgraph_borrow(handle)
    return shapedType.shape != nil
}

@_cdecl("mpsgraph_shaped_type_shape_len")
public func mpsgraph_shaped_type_shape_len(_ handle: UnsafeMutableRawPointer?) -> Int {
    guard let handle else {
        return 0
    }
    let shapedType: MPSGraphShapedType = mpsgraph_borrow(handle)
    return shapedType.shape?.count ?? 0
}

@_cdecl("mpsgraph_shaped_type_copy_shape")
public func mpsgraph_shaped_type_copy_shape(
    _ handle: UnsafeMutableRawPointer?,
    _ outShape: UnsafeMutablePointer<Int>?
) {
    guard let handle, let outShape else {
        return
    }
    let shapedType: MPSGraphShapedType = mpsgraph_borrow(handle)
    guard let shape = shapedType.shape else {
        return
    }
    for (index, value) in shape.enumerated() {
        outShape[index] = value.intValue
    }
}

@_cdecl("mpsgraph_shaped_type_data_type")
public func mpsgraph_shaped_type_data_type(_ handle: UnsafeMutableRawPointer?) -> UInt32 {
    guard let handle else {
        return 0
    }
    let shapedType: MPSGraphShapedType = mpsgraph_borrow(handle)
    return shapedType.dataType.rawValue
}

@_cdecl("mpsgraph_shaped_type_set_shape")
public func mpsgraph_shaped_type_set_shape(
    _ handle: UnsafeMutableRawPointer?,
    _ shape: UnsafePointer<Int>?,
    _ shapeLen: Int
) -> Bool {
    guard let handle else {
        return false
    }
    let shapedType: MPSGraphShapedType = mpsgraph_borrow(handle)
    shapedType.shape = mpsgraph_optional_signed_shape(shape, shapeLen)
    return true
}

@_cdecl("mpsgraph_shaped_type_set_data_type")
public func mpsgraph_shaped_type_set_data_type(
    _ handle: UnsafeMutableRawPointer?,
    _ dataTypeRaw: UInt32
) -> Bool {
    guard let handle, let dataType = mpsgraph_data_type(dataTypeRaw) else {
        return false
    }
    let shapedType: MPSGraphShapedType = mpsgraph_borrow(handle)
    shapedType.dataType = dataType
    return true
}

@_cdecl("mpsgraph_shaped_type_is_equal")
public func mpsgraph_shaped_type_is_equal(
    _ handle: UnsafeMutableRawPointer?,
    _ otherHandle: UnsafeMutableRawPointer?
) -> Bool {
    guard let handle else {
        return false
    }
    let shapedType: MPSGraphShapedType = mpsgraph_borrow(handle)
    let other = otherHandle.map { (ptr: UnsafeMutableRawPointer) -> MPSGraphShapedType in
        mpsgraph_borrow(ptr)
    }
    return shapedType.isEqual(to: other)
}

@_cdecl("mpsgraph_tensor_has_shape")
public func mpsgraph_tensor_has_shape(_ handle: UnsafeMutableRawPointer?) -> Bool {
    guard let handle else {
        return false
    }
    let tensor: MPSGraphTensor = mpsgraph_borrow(handle)
    return tensor.shape != nil
}

@_cdecl("mpsgraph_tensor_shape_len")
public func mpsgraph_tensor_shape_len(_ handle: UnsafeMutableRawPointer?) -> Int {
    guard let handle else {
        return 0
    }
    let tensor: MPSGraphTensor = mpsgraph_borrow(handle)
    return tensor.shape?.count ?? 0
}

@_cdecl("mpsgraph_tensor_copy_shape")
public func mpsgraph_tensor_copy_shape(
    _ handle: UnsafeMutableRawPointer?,
    _ outShape: UnsafeMutablePointer<Int>?
) {
    guard let handle, let outShape else {
        return
    }
    let tensor: MPSGraphTensor = mpsgraph_borrow(handle)
    guard let shape = tensor.shape else {
        return
    }
    for (index, value) in shape.enumerated() {
        outShape[index] = value.intValue
    }
}

@_cdecl("mpsgraph_tensor_data_type")
public func mpsgraph_tensor_data_type(_ handle: UnsafeMutableRawPointer?) -> UInt32 {
    guard let handle else {
        return 0
    }
    let tensor: MPSGraphTensor = mpsgraph_borrow(handle)
    return tensor.dataType.rawValue
}

@_cdecl("mpsgraph_tensor_operation")
public func mpsgraph_tensor_operation(_ handle: UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer? {
    guard let handle else {
        return nil
    }
    let tensor: MPSGraphTensor = mpsgraph_borrow(handle)
    return mpsgraph_retain(tensor.operation)
}