For those following along, it turns out that this actually is doable:
func bindArrayToTuple<T, U>(array: Array<T>, tuple: inout U) {
withUnsafeMutablePointer(to: &tuple) {
$0.withMemoryRebound(to: T.self, capacity: array.count) {
let ptr = UnsafeMutableBufferPointer<T>(start: $0, count: array.count)
for (index, value) in array.enumerated() {
ptr[index] = value
}
}
}
}I've tried your bindArrayToTuple. It's worked so far in my testing.
Thanks!
You can do it more compactly thanks to array-pointer magic:
func bindArrayToTuple<T, U>(array: Array<T>, tuple: inout U) {
withUnsafeMutablePointer(to: &tuple) {
$0.withMemoryRebound(to: T.self, capacity: array.count) {
$0.assign(from: array, count: array.count)
}
}
}Awesome I will try this out!
Hey there,
Slight variation on your suggestion:
func bindArrayToTuple<T, U>(array: Array<T>, tuple: UnsafeMutablePointer<U>) {
tuple.withMemoryRebound(to: T.self, capacity: array.count) {
$0.assign(from: array, count: array.count)
}
}
It's a little cleaner and the call site doesn't change.
If you are going to use this sort of code, I suggest making sure that you're not overflowing the bounds of the tuple.
precondition(
MemoryLayout<U>.stride >= array.count * MemoryLayout<T>.stride,
"too many elements in array")
precondition(
MemoryLayout<U>.alignment == MemoryLayout<T>.alignment,
"elements are not the same type (this is an overly conservative test and it still failed)")
Good idea I'll add the preconditions.
If you are going to use this sort of code
Does this mean there is a better alternative?
Technically you're not allowed to use withMemoryRebound(to:capacity:) for a type of a different size; the correct use of pointers would be to go through UnsafeMutableRawPointer and use assumingMemoryBound(to:), since the tuple's elements are a "related type".
Besides that, though, there probably isn't a better solution if you care about performance. I sketched out something similar recently and wasn't really happy with it either. You could make it slightly safer by using reflection to check that the tuple really is homogeneous (all children have the same type and it's the same as the array's element type), and then check that the tuple's stride is the same as the element stride times the number of children in the tuple, to make sure it really is a tuple and not some monstrosity masquerading as a tuple.
(Even that isn't 100% safe, but it's closer. Mirror should probably have an enum asking what kind of value something is, like displayStyle but without being fakeable. But the language / standard library should also have built-in safe answers for homogeneous tuples / fixed-sized arrays, and the team knows that.)
Thanks, very informative :)
Going back the larger issue, "this sort of code" wouldn't be necessary if there was a better way of handling the translation for imported C structs.
While we're waiting for fixed-size Swift arrays, it occurs to me that C's own horrible solution to the equivalent problem might actually be a better solution for importing into Swift. For example, start from a slightly expanded original:
typedef struct {
int count;
float weights[51];
int hash;
} Uniforms;
Rather than translating this into:
struct Uniforms {
var count: Int
var weights: (Float, Float, …, Float)
var hash: Int
}
it might work better to translate into this:
struct Uniforms {
var count: Int
var _: (Float, Float, …, Float) // not an actual member, just a space placeholder
var hash: Int
var weights: UnsafeMutableBufferPointer<Float> {
return … // a buffer pointer to the start of the placeholder in the struct
}
}
Note that this might not be the best choice if the array is the last field in the struct, because the following kind of thing:
typedef struct {
int count;
float weights[0];
} Uniforms;
or
typedef struct {
int count;
float weights[1];
} Uniforms;
tends to indicate a variable length struct in C. In that case, the computed property would be better as an UnsafeMutablePointer, instead of an UnsafeMutableBufferPointer.
Also, I'm aware this is source-breaking, but in this case the current behavior is so horrible, it'd be a positive good to break source compatibility.
That idea's been floated before, but it wouldn't be correct since a value doesn't inherently have an address. The UnsafeMutableBufferPointer would be invalid as soon as the getter returned.
I was actually headed towards something analogous to Array.withUnsafeBufferPointer(_:), maybe a synthesized Uniforms.withUnsafeBufferPointer(weights:_:) method on the struct.
If you want a Swift struct Uniforms with the same memory layout as the C struct, and you want subscript access to its (statically allocated) weights, then you can start by writing some reusable code for managing "hacky statically allocated fixed size arrays in Swift", for example this:
protocol FixedSizeArray {
associatedtype Element
static var count: Int { get }
}
extension FixedSizeArray {
var count: Int { return Self.count }
subscript(unchecked index: Int) -> Element {
get {
return withUnsafeBytes(of: self) { (ptr) -> Element in
let o = index &* MemoryLayout<Element>.stride
return ptr.load(fromByteOffset: o, as: Element.self)
}
}
set {
withUnsafeMutableBytes(of: &self) { (ptr) -> Void in
let o = index &* MemoryLayout<Element>.stride
ptr.storeBytes(of: newValue, toByteOffset: o, as: Element.self)
}
}
}
subscript(index: Int) -> Element {
get {
typealias ML<T> = MemoryLayout<T>
precondition(ML<Self>.alignment == ML<Element>.alignment)
precondition(Self.count * ML<Element>.stride == ML<Self>.size)
precondition(0 <= index && index < Self.count)
return self[unchecked: index]
}
set {
typealias ML<T> = MemoryLayout<T>
precondition(ML<Self>.alignment == ML<Element>.alignment)
precondition(Self.count * ML<Element>.stride == ML<Self>.size)
precondition(0 <= index && index < Self.count)
self[unchecked: index] = newValue
}
}
}
With that in place, you can now do this for your particular example:
struct Float_x51 : FixedSizeArray {
static var count: Int { return 51 }
typealias Element = Float
private var _storage = (
Float(0), Float(0), Float(0), Float(0), Float(0),
Float(0), Float(0), Float(0), Float(0), Float(0),
Float(0), Float(0), Float(0), Float(0), Float(0),
Float(0), Float(0), Float(0), Float(0), Float(0),
Float(0), Float(0), Float(0), Float(0), Float(0),
Float(0), Float(0), Float(0), Float(0), Float(0),
Float(0), Float(0), Float(0), Float(0), Float(0),
Float(0), Float(0), Float(0), Float(0), Float(0),
Float(0), Float(0), Float(0), Float(0), Float(0),
Float(0), Float(0), Float(0), Float(0), Float(0),
Float(0)
)
}
struct Uniforms {
var weights: Float_x51
init() {
weights = Float_x51()
}
}
func test() {
var uniforms = Uniforms()
print(MemoryLayout.size(ofValue: uniforms)) // 204 == 51 * 4 bytes
for i in 0 ..< uniforms.weights.count {
uniforms.weights[i] = Float.random(in: -1 ... 1)
}
for i in 0 ..< uniforms.weights.count {
print(uniforms.weights[i])
}
}
test()
Note that the FixedSizeArray's regular (checked) subscript checks that any given fixed size array's Element and count matches its memory layout, so it's perfectly safe! 
Minor tweak to your checks:
- precondition(Self.count * ML<Element>.stride == ML<Self>.size)
+ precondition(Self.count * ML<Element>.stride == ML<Self>.stride)
or perhaps
- precondition(Self.count * ML<Element>.stride == ML<Self>.size)
+ precondition(Self.count == 0 ? (ML<Self>.size == 0) : ((Self.count - 1) * ML<Element>.stride + ML<Element>.size == ML<Self>.size))
As demonstrated here:
1> struct X { var a: Int64; var b: Int8 }
2> MemoryLayout<X>.size
$R0: Int = 9
3> MemoryLayout<X>.stride
$R1: Int = 16
4> MemoryLayout<(X, X)>.stride
$R2: Int = 32
5> MemoryLayout<(X, X)>.size
$R3: Int = 25
6> MemoryLayout<(X, X, X)>.stride
$R4: Int = 48
7> MemoryLayout<(X, X, X)>.size
$R5: Int = 41
Ah, thanks! And maybe the alignment of Element should be allowed to be less than that of Self?
And all checks except the bounds check could of course be moved to the initializer instead of the subscript ...
Depends what you're going for. If this is really only meant to be used with homogeneous tuples, it'll always be equal.
Hello Jens,
I appreciate the suggestion, but unless I'm missing something I don't think this really solves the issue. In your example, I'd still have to type out 51 Floats at least once, which is fine, but what if I decide to change my number of weights to 5001? In the method that I suggested previously (modified to include Jordan's suggested preconditions), I wouldn't have to change anything, but in your solution, I would have to create a Float_x5001, and type out 5001 Floats!
I see what you mean. Your solution might be simpler for your specific use case.
But that Float_x51 was just meant as an example of a type that can implement the FixedSizeArray protocol. In your scenario that would have been the Uniforms struct imported from C.
That is, in your project you have this:
// my-c-types.h
typedef struct {
float weights[51];
} Uniforms;
And you have a bridging header file with #import "my-c-types.h".
Then, you'd use the FixedSizeArray protocol as follows (no matter if the C array has 51, 42 or 123 elements):
extension Uniforms : FixedSizeArray { // This is all you have to do to
static var count: Int { 51 } // add subscript access to a
typealias Element = Float // C imported type like Uniforms.
}
func test() {
var u = Uniforms()
for i in 0 ..< u.count {
u[i] = Float(i) // Or whatever you'd like to set the values to.
}
}
test()
And, as long as you use the regular subscript (rather than the unchecked one) it will trap if you accidentally specified a count or Element that doesn't match the memory layout of the C struct.
Since the protocol has subscripts and count, it can easily be extended to implement RandomAccessCollection.
protocol FixedSizeArray : RandomAccessCollection {
associatedtype Element
static var count: Int { get }
}
extension FixedSizeArray {
public var count: Int { return Self.count }
public var startIndex: Int { 0 }
public var endIndex: Int { Self.count }
public subscript(unchecked index: Int) -> Element {
get {
return withUnsafeBytes(of: self) { (ptr) -> Element in
let o = index &* MemoryLayout<Element>.stride
return ptr.load(fromByteOffset: o, as: Element.self)
}
}
set {
withUnsafeMutableBytes(of: &self) { (ptr) -> Void in
let o = index &* MemoryLayout<Element>.stride
ptr.storeBytes(of: newValue, toByteOffset: o, as: Element.self)
}
}
}
public subscript(index: Int) -> Element {
get {
typealias ML<T> = MemoryLayout<T>
precondition(ML<Self>.alignment == ML<Element>.alignment)
precondition(Self.count * ML<Element>.stride == ML<Self>.stride)
precondition(0 <= index && index < Self.count)
return self[unchecked: index]
}
set {
typealias ML<T> = MemoryLayout<T>
precondition(ML<Self>.alignment == ML<Element>.alignment)
precondition(Self.count * ML<Element>.stride == ML<Self>.stride)
precondition(0 <= index && index < Self.count)
self[unchecked: index] = newValue
}
}
}
If the Uniforms C struct had contained not only the array, you'd have to modify the protocol so that you conform by also specifying a byteOffset to where the array starts (as well as count and Element). But in such cases you'd probably want to use an all together different approach.
Ah I see now, thank you for clarifying!
To round this out, I wrote this as a global function, so that structs with tuple pseudo-arrays can be accessed without having to extend each one explicitly. My version:
func withUnsafeMutableBufferPointer<Struct,Element,Tuple,R>(
to value: inout Struct,
at property: WritableKeyPath<Struct,Tuple>,
using type: Element.Type,
_ body: (UnsafeMutableBufferPointer<Element>) throws -> R) rethrows -> R {
return try withUnsafeMutablePointer(to: &value [keyPath: property]) {
let count = MemoryLayout<Tuple>.stride / MemoryLayout<Element>.stride
return try $0.withMemoryRebound(to: Element.self, capacity: count) {
return try body(UnsafeMutableBufferPointer(start: $0, count: count))
}
}
}
used like this:
struct Uniforms { // assume this came from an imported header
var weights: (Float, Float, Float, Float)
}
var uniforms = Uniforms(weights: (1,2,3,4))
print("Uniforms: \(uniforms)") // 'Uniforms: Uniforms(weights: (1.0, 2.0, 3.0, 4.0))'
withUnsafeMutableBufferPointer(to: &uniforms, at: \.weights, using: Float.self) {
for index in 0 ..< $0.count {
$0 [index] *= 2
}
}
print("Uniforms: \(uniforms)") // 'Uniforms: Uniforms(weights: (2.0, 4.0, 6.0, 8.0))'
Ideally, though, I'd like to see the C header importer conform such structs to a protocol that provides this functionality as an instance method. I'd also like to see a distinction between accessing a fixed size C array (Unsafe[Mutable]BufferPointer) and a variable size C array (Unsafe[Mutable]Pointer).