相关疑难解决方法(0)

我发现这个主题为什么处理排序数组比未排序数组更快？.并尝试运行此代码.而且我发现了奇怪的行为.如果我使用-O3优化标志编译此代码,则需要2.98605 sec运行.如果我用-O2它编译1.98093 sec.我尝试在同一环境中的同一台机器上运行此代码几次(5或6),我关闭所有其他软件(chrome,skype等).

gcc --version
gcc (Ubuntu 4.9.2-0ubuntu1~14.04) 4.9.2
Copyright (C) 2014 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

那么请你能解释一下为什么会这样吗？我阅读gcc手册,我看到-O3包括-O2.谢谢你的帮助.

PS添加代码

#include <algorithm>
#include <ctime>
#include <iostream>

int main()
{
    // Generate data
    const unsigned arraySize = 32768;
    int data[arraySize];

    for (unsigned …

在最新的 x86 架构上，存储到加载转发失败的成本是多少？

特别是，存储到加载转发会失败，因为加载部分与较早的存储重叠，或者因为较早的加载或存储跨越某些导致转发失败的对齐边界。

当然存在延迟成本：它有多大？是否还存在吞吐量成本，例如，失败的存储到加载转发是否使用了其他加载和存储甚至其他非内存操作无法使用的额外资源？

当存储的所有部分都来自存储缓冲区时，与混合存储缓冲区和 L1 的情况相比，是否有区别？

如果负载与两个早期存储重叠(并且负载未完全包含在最早的存储中),现代Intel或AMD x86实现是否可以从两个存储转发以满足负载？

例如,请考虑以下顺序:

mov [rdx + 0], eax
mov [rdx + 2], eax
mov ax, [rdx + 1]

最后的2字节加载从前一个存储区获取其第二个字节,但是它之前的存储区的第一个字节.这个负载可以存储转发,还是需要等到两个先前的存储都提交给L1？

请注意,通过存储转发,我包括任何可以满足仍然存储在缓冲区中的存储的读取的机制,而不是等待它们提交到L1,即使它是一个比最好的情况"转发"更慢的路径.单店"案例.

在对涉及 的代码进行基准测试时std::optional<double>，我注意到 MSVC 生成的代码的运行速度大约是 clang 或 gcc 生成的代码的一半。在花了一些时间减少代码后，我注意到 MSVC 显然在为std::optional::operator=. 使用std::optional::emplace()不会表现出速度减慢。

以下功能

void test_assign(std::optional<double> & f){
    f = std::optional{42.0};
}

产生

sub     rsp, 24
vmovsd  xmm0, QWORD PTR __real@4045000000000000
mov     BYTE PTR $T1[rsp+8], 1
vmovups xmm1, XMMWORD PTR $T1[rsp]
vmovsd  xmm1, xmm1, xmm0
vmovups XMMWORD PTR [rcx], xmm1
add     rsp, 24
ret     0

注意未对齐的 mov 操作。相反，函数

void test_emplace(std::optional<double> & f){
    f.emplace(42.0);
}

编译为

mov     rax, 4631107791820423168      ; 4045000000000000H
mov     BYTE PTR [rcx+8], 1
mov …

我在llvm clang Apple LLVM 8.0.0版(clang-800.0.42.1)上反汇编代码:

int main() {
    float a=0.151234;
    float b=0.2;
    float c=a+b;
    printf("%f", c);
}

我编译时没有-O规范,但我也试过-O0(给出相同)和-O2(实际上计算值并存储它预先计算)

产生的反汇编如下(我删除了不相关的部分)

->  0x100000f30 <+0>:  pushq  %rbp
    0x100000f31 <+1>:  movq   %rsp, %rbp
    0x100000f34 <+4>:  subq   $0x10, %rsp
    0x100000f38 <+8>:  leaq   0x6d(%rip), %rdi       
    0x100000f3f <+15>: movss  0x5d(%rip), %xmm0           
    0x100000f47 <+23>: movss  0x59(%rip), %xmm1        
    0x100000f4f <+31>: movss  %xmm1, -0x4(%rbp)  
    0x100000f54 <+36>: movss  %xmm0, -0x8(%rbp)
    0x100000f59 <+41>: movss  -0x4(%rbp), %xmm0         
    0x100000f5e <+46>: addss  -0x8(%rbp), %xmm0
    0x100000f63 <+51>: movss  %xmm0, -0xc(%rbp)
    ...

显然它正在做以下事情:

1. 将两个浮点数加载到寄存器xmm0和xmm1上
2. 把它们放在堆栈中
3. 从堆栈加载一个值(不是之前的xmm0)到xmm0
4. 执行添加. …

我正在使用 node.js 开发后端项目，并将实现排序产品功能。我研究了一些文章，有几篇文章说冒泡排序效率不高。冒泡排序在我之前的项目中使用过，我很惊讶为什么它很糟糕。谁能解释为什么它效率低下？如果您可以通过 c 编程或汇编命令进行解释，将不胜感激。

我从同事那里听说 C++ 比 Java 更快，在寻求最高性能时，特别是对于金融应用程序，这是一条必经之路。但我的观察有点不同。谁能指出我实验的失败或在讨论中添加一些科学变量？

注1：我在 C++ 编译器中使用-O3（最大优化）和-O2 。

注2：包含每种语言的简短完整源代码。您可以随意在自己的机器上运行、进行更改、得出结论并分享。

注意3：如果将两个源代码并排放在编辑器中，您将看到它们的实现是等效的。

更新：我尝试clang++过g++各种优化选项（-O2、-O3、-Os、-march=native等），它们都产生了比 Java 慢的结果。我认为此时为了使 C++ 更快，我必须深入研究生成的汇编代码并进行一些汇编编程。我想知道在编写大型实际应用程序时这种方法（汇编编程和汇编调试）有多实用。

基准测试有什么作用？

• 在堆中（而不是在堆栈中）创建一个int数组
• 启动时钟
• 填充数组
• 使用冒泡排序对数组进行排序
• 停止时钟

执行 1000 万次，丢弃前 100 万次进行预热，并输出平均、最短和最长时间。

对于C++我得到：（使用 -O3 和 -O2）

$ g++ --version
g++ (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0

$ g++ TimeBubbleSort.cpp -o TimeBubbleSort -std=c++11 -O3
$ ./TimeBubbleSort 10000000 1000000 60
Value …