let n = 1000000
let x = Int[](count: n,repeatedValue: 0)
for i in 0..n {
x[i] = random()
}
// start clock here
let y = sort(x)
// stop clock here
在C中，类似的操作在我的计算机上需要0.06秒。
在Python中，它需要0.6秒(没有技巧，只有y = sorted(x)为整数列表)。
在Swift中，如果我使用以下命令编译它需要6秒：
xcrun swift -O3 -sdk `xcrun --show-sdk-path --sdk macosx`
如果我用下面的命令编译它需要88秒的时间：
xcrun swift -O0 -sdk `xcrun --show-sdk-path --sdk macosx`
“Xcode”中的“发布”与“调试”构建的时间是类似的。
这里有什么问题？我可以理解一些性能损失与C相比，但不是一个10倍的放缓与纯Python相比。
编辑：mweathers注意到，将-O3更改为-Ofast使此代码运行几乎与C版本一样快！但是，-Ofast很多地改变了语言的语义 – 在我的测试中，它禁用了对整数溢出和数组索引溢出的检查。例如，使用-Ofast，以下Swift代码静默运行而不会崩溃(并打印出一些垃圾)：
let n = 10000000 println(n*n*n*n*n) let x = Int[](count: n,repeatedValue: 10) println(x[n])
所以 – 快速不是我们想要的; Swift的整个观点是我们有安全网。当然，安全网对性能有一些影响，但它们不应该使程序慢100倍。记住，Java已经检查了数组边界，在典型的情况下，减速的大小要小于2.在Clang和GCC中，我们有-ftrapv用于检查(有符号)整数溢出，而不是那么慢。
因此，问题：我们如何在不失去安全网的情况下在Swift中获得合理的性能？
编辑2：我做了更多的基准，有非常简单的循环
for i in 0..n {
x[i] = x[i] ^ 12345678
}
(这里的xor操作只是为了我可以更容易找到相关的循环在汇编代码。我试图选择一个容易发现的操作，但也“无害”的意义上，它不应该要求任何检查相关到整数溢出。)
同样，-O3和-Ofast之间的性能有很大的不同。所以我看了汇编代码：
>用-Ofast我几乎得到了我的期望。相关部分是一个带有5个机器语言指令的循环。
>用-O3我得到的东西，超出了我最疯狂的想象力。内循环跨越88行汇编代码。我没有试图理解所有的，但最可疑的部分是13调用“callq _swift_retain”和另外13个调用“callq _swift_release”。也就是说，在内循环中有26个子程序调用！
编辑3：在评论中，Ferruccio要求公平的基准，他们不依赖于内置函数(例如排序)。我认为以下程序是一个相当好的例子：
let n = 10000
let x = Int[](count: n,repeatedValue: 1)
for i in 0..n {
for j in 0..n {
x[i] = x[j]
}
}
没有算术，所以我们不需要担心整数溢出。我们做的只是很多数组引用。结果是这里 – Swift -O3损失的因子差不多500与相比-Ofast：
> C-O3：0.05s
> C-O0：0.4s
> Java：0.2 s
> Python with PyPy：0.5 s
> Python：12秒
>快速：快速：0.05秒
> Swift -O3：23秒
> Swift -O0：443 s
(如果你担心编译器可能会完全优化无意义的循环，你可以把它改成例如x [i] ^ = x [j]，并添加一个输出x [0]的print语句。 ;时间将非常类似。)
是的，这里的Python实现是一个愚蠢的纯Python实现与一列int和嵌套for循环。它应该比未优化的Swift慢得多。一些似乎严重破坏与Swift和数组索引。
编辑4：这些问题(以及一些其他性能问题)似乎已经修复在Xcode 6 beta 5。
对于排序，我现在有以下定时：
> ang -O3：0.06s
> swiftc -Ofast：0.1 s
> swiftc -O：0.1 s
> swiftc：4秒
对于嵌套循环：
> ang -O3：0.06s
> swiftc -Ofast：0.3 s
> swiftc -O：0.4s
> swiftc：540 s
似乎没有理由再使用不安全的-Ofast(a.k.a. -Ounchecked); plain -O产生同样好的代码。
这里是一个在Swift的就地快速：
func quicksort_swift(inout a:CInt[],start:Int,end:Int) {
if (end - start < 2){
return
}
var p = a[start + (end - start)/2]
var l = start
var r = end - 1
while (l <= r){
if (a[l] < p){
l += 1
continue
}
if (a[r] > p){
r -= 1
continue
}
var t = a[l]
a[l] = a[r]
a[r] = t
l += 1
r -= 1
}
quicksort_swift(&a,start,r + 1)
quicksort_swift(&a,r + 1,end)
}
和C一样：
void quicksort_c(int *a,int n) {
if (n < 2)
return;
int p = a[n / 2];
int *l = a;
int *r = a + n - 1;
while (l <= r) {
if (*l < p) {
L++;
continue;
}
if (*r > p) {
r--;
continue;
}
int t = *l;
*L++ = *r;
*r-- = t;
}
quicksort_c(a,r - a + 1);
quicksort_c(l,a + n - l);
}
两者工作：
var a_swift:CInt[] = [0,5,2,8,1234,-1,2] var a_c:CInt[] = [0,2] quicksort_swift(&a_swift,a_swift.count) quicksort_c(&a_c,CInt(a_c.count)) // [-1,1234] // [-1,1234]
两者都在同一个程序中调用。
var x_swift = CInt[](count: n,repeatedValue: 0)
var x_c = CInt[](count: n,repeatedValue: 0)
for var i = 0; i < n; ++i {
x_swift[i] = CInt(random())
x_c[i] = CInt(random())
}
let swift_start:UInt64 = mach_absolute_time();
quicksort_swift(&x_swift,x_swift.count)
let swift_stop:UInt64 = mach_absolute_time();
let c_start:UInt64 = mach_absolute_time();
quicksort_c(&x_c,CInt(x_c.count))
let c_stop:UInt64 = mach_absolute_time();
这将绝对时间转换为秒：
static const uint64_t NANOS_PER_USEC = 1000ULL;
static const uint64_t NANOS_PER_MSEC = 1000ULL * NANOS_PER_USEC;
static const uint64_t NANOS_PER_SEC = 1000ULL * NANOS_PER_MSEC;
mach_timebase_info_data_t timebase_info;
uint64_t abs_to_nanos(uint64_t abs) {
if ( timebase_info.denom == 0 ) {
(void)mach_timebase_info(&timebase_info);
}
return abs * timebase_info.numer / timebase_info.denom;
}
double abs_to_seconds(uint64_t abs) {
return abs_to_nanos(abs) / (double)NANOS_PER_SEC;
}
下面是编译器优化级别的摘要：
[-Onone] no optimizations,the default for debug. [-O] perform optimizations,the default for release. [-Ofast] perform optimizations and disable runtime overflow checks and runtime type checks.
对于n = 10_000，使用[-Onone]的时间(以秒为单位)：
Swift: 0.895296452 C: 0.001223848
这里是Swift的内置sort()对于n = 10_000：
Swift_builtin: 0.77865783
这里是[-O]为n = 10_000：
Swift: 0.045478346 C: 0.000784666 Swift_builtin: 0.032513488
正如你所看到的，Swift的性能提高了20倍。
根据mweathers’ answer，设置[-Ofast]产生真正的区别，导致n = 10_000的这些时间：
Swift: 0.000706745 C: 0.000742374 Swift_builtin: 0.000603576
对于n = 1_000_000：
Swift: 0.107111846 C: 0.114957179 Swift_sort: 0.092688548
为了比较，对于n = 1_000_000使用[-Onone]
Swift: 142.659763258 C: 0.162065333 Swift_sort: 114.095478272
因此，在这个基准测试中，Swift在没有优化的情况下比C的性能差了近1000倍。另一方面，两个编译器都设置为[-Ofast] Swift实际上至少执行，如果不是稍好于C.
已经指出，[-Ofast]改变语言的语义，使其可能不安全。这是苹果在Xcode 5.0发行说明中说的：
A new optimization level -Ofast,available in LLVM,enables aggressive optimizations. -Ofast relaxes some conservative restrictions,mostly for floating-point operations,that are safe for most code. It can yield significant high-performance wins from the compiler.
他们都提倡。无论是聪明还是不，我不能说，但从我可以告诉它似乎足够合理的使用[-Ofast]在一个版本，如果你不做高精度浮点运算，你没有信心没有整数或阵列溢出可能在您的程序。如果你需要高性能和溢出检查/精确算术，现在选择另一种语言。
BETA 3更新：
n = 10_000，其中[-O]：
Swift: 0.019697268 C: 0.000718064 Swift_sort: 0.002094721
Swift通常有点快，看起来Swift的内置排序已经发生了很大的变化。
最终更新：
[-在一个]：
Swift: 0.678056695 C: 0.000973914
[-O]：
Swift: 0.001158492 C: 0.001192406
[-Ounchecked]：
Swift: 0.000827764 C: 0.001078914