Arrays 为什么Swift编译器会以16字节的倍数为基本类型的数组预先分配空间？（64位英特尔计算机）

我注意到，当创建任何基本类型的数组时，给定

sizeof（..）

MacOS X和iOS上的所有分配都是通过16字节对齐完成的，不限于Swift，多年来一直如此。由于单个项更可能包含在单个缓存线中，因此这会提高一些速度，如果使用向量操作，则会提高一些速度。它简化了分配和解除分配的算法。此外，它允许“标记指针对象”，因为指向对象的任何指针的最后四位都保证为零

我猜应该是缓存行对齐。我明白了，谢谢你的回答。我将为未来可能的访问者添加这些相关链接（在上面给出您的解释后找到），这种16字节的对齐方式似乎至少从MacOSX10.5开始就被使用了。

/* Memory footprint */
sizeof(().dynamicType) // 0
sizeof(Bool) // 1
sizeof(Int16) // 2
sizeof(Int32) // 4
sizeof(Int64) // 8
sizeof(Float) // 4
sizeof(Double) // 8
sizeof(String) // 24 <-- for this, in multiples of 24 bytes, OK

/* Default pre-allocation in multiples of 16 bytes? */
let boolArr : [Bool] = [true]
let boolArrExact = [Bool](count: 16, repeatedValue: true)
let boolArrNext = [Bool](count: 17, repeatedValue: true)
let boolArrNextNext = [Bool](count: 33, repeatedValue: true)
boolArr.capacity // 16 elements <=> 16 bytes
boolArrExact.capacity // 16 elements <=> 16 bytes
boolArrNext.capacity // 32 elements <=> 32 bytes
boolArrNextNext.capacity // 48 elements <=> 48 bytes

let int16arr = [Int16](count: 1, repeatedValue: 1)
let int16arrExact = [Int16](count: 8, repeatedValue: 1)
let int16arrNext = [Int16](count: 9, repeatedValue: 1)
int16arr.capacity // 8 elements <=> 2*8 = 16 bytes
int16arrExact.capacity // 8 elements <=> 2*8 = 16 bytes
int16arrNext.capacity // 16 elements <=> 2*(2*8) = 32 bytes

let int64arr = [Int64](count: 1, repeatedValue: 1)
let int64arrNext = [Int64](count: 3, repeatedValue: 1)
int64arr.capacity // 2 elements <=> 8*2 = 16 bytes
int64arrNext.capacity // 4 elements <=> 2*(8*2) = 32 bytes

/* even when explicitly reserving capacity for less than default */
var boolArrCustomA : [Bool] = []
boolArrCustomA.reserveCapacity(5) // 8 bytes should suffice
boolArrCustomA.append(true)
boolArrCustomA.capacity // 16

var boolArrCustomB : [Bool] = []
boolArrCustomB.reserveCapacity(17) // 24 bytes should suffice
boolArrCustomB.append(true)
boolArrCustomB.capacity // 32