我愿意编写使我的CPU执行某些操作的代码，并查看他花费多少时间来解决这些问题。我想做一个从i = 0到i <5000的循环，然后将i乘以一个常数并乘以该时间。我结束了这段代码，它没有错误，但是即使我更改循环i><49058349083或i><>

PD:我昨天开始学习C++，很抱歉，如果这是一个很容易回答的问题，但找不到解决方案

#include <iostream>
#include <ctime>

using namespace std;

int main () {
    int start_s=clock();

    int i;
    for(i=0;i<5000;i++){
        i*434243;
    }

    int stop_s=clock();
    cout << "time: "<< (stop_s-start_s)/double(CLOCKS_PER_SEC)*1000;

    return 0;
}

最佳答案

顺便说一句，如果您实际上完成了i<49058349083，则gcc和clang在具有32位int(包括x86和x86-64)的系统上创建一个无限循环。 49058349083大于INT_MAX。大字面量会隐式提升为足以容纳它们的类型，因此您有效地做了(int64_t)i < 49058349083LL，这对于int i的任何可能值都是正确的。
有符号溢出是C++中的未定义行为，无限循环也是没有任何副作用的无限循环(例如系统调用)，因此I checked on the Godbolt compiler explorer可以查看它在启用优化的情况下是如何真正编译的。有趣的事实:当条件是始终为真的比较，而不是像i*10这样的非零常量时，MSVC仍会优化掉一个空循环(包括一个未分配42的空循环)。

这样的循环从根本上来说是有缺陷的。
您可以使用Google的基准测试包(How would you benchmark the performance of a function?)微基准测试完整的非内联函数，但要通过将某些内容放入重复循环中来学习有用的知识，则必须了解很多有关编译器如何编译为asm的信息，以及您真正要使用的内容。重新尝试进行度量，以及如何使优化器制作类似于您在某些实际使用上下文中从代码中获得的asm的asm。例如通过using inline asm to require it to have a certain result in a register或分配给volatile变量(也有进行存储的开销)。
如果这听起来比您希望的要复杂得多，那就太糟糕了，这是有充分理由的。
那是因为编译器是非常复杂的机器，通常可以从源代码中生成相当有效的可执行文件，而这些可执行文件的目的是清楚地表达人类读者正在发生的事情，而不是避免多余的工作或看起来像高效的机器语言实现(这就是事实)。您的CPU实际上正在运行)。

微基准测试很难-除非您了解代码的编译方式和实际测量内容，否则您将无法获得有意义的结果。
优化编译器的目的是创建一个可执行文件，该可执行文件与C++源代码产生的结果相同，但运行速度尽可能快。性能不是可观察到的结果，因此使程序更高效始终是合法的。这是“假设”规则:What exactly is the "as-if" rule?
您希望编译器不要浪费时间和未使用的代码大小的计算结果。编译器将函数内联到调用程序中后，通常会发现它没有使用某些计算出来的东西。编写良好的C++代码通常会放弃很多工作，包括完全优化临时变量，这是正常的。这不是一件坏事，没有这样做的编译器会很烂。
请记住，您是为C++抽象机编写的，但是编译器的工作是将其翻译为CPU的汇编语言(或机器代码)。汇编语言与C++完全不同。 (现代高性能的CPU也可以不按顺序执行指令，同时遵循自己的“按条件”规则，以保留编译器生成的代码按程序顺序运行的错觉。但是CPU不能放弃工作，只能重叠它。)
在通常情况下的中，即使在您自己的桌面上，也无法对C++中的int * int二进制运算符进行微基准测试(不要在其他硬件/不同的编译器上使用)。在不同上下文中的不同用法将编译为不同的代码。即使您可以创建测量某些有用内容的循环版本，也不一定会告诉您其他程序中foo = a * b的价格如何。另一个程序可能会遇到乘法延迟而不是吞吐量的瓶颈，或者将该乘法与附近对a或b或任何其他事物的操作结合起来。

不要禁用优化
您可能会认为仅禁用优化(例如gcc -O0而不是gcc -O3)会很有用。但是做的唯一方法还引入了反优化，例如在每个C++语句之后将每个值存储回内存，以及从内存中为下一个语句重新加载变量。这使您可以在调试已编译的程序时修改变量值，甚至可以跳到同一函数中的新行，并且仍然可以通过查看C++源代码获得所需的结果。
支持该级别的干扰会给编译器带来巨大负担。在典型的现代x86上，存储/重新加载(存储转发)的延迟约为5个周期。这意味着反优化循环最多只能在每个〜6个时钟周期内运行一次迭代，而对于像looptop: dec eax/jnz looptop这样的紧密循环(其中循环计数器位于寄存器中)的紧密循环，则只能运行1个循环。
没有太多的中间立场:编译器没有使“看起来”像C++源的asm的选项，而是将值保留在语句的寄存器中。无论如何，这将毫无用处或有意义，因为这不是启用完全优化的情况下它们的编译方式。 (gcc -Og可能有点像这样。)
花时间修改C++以使其与-O0一起运行更快，这完全是浪费时间:C loop optimization help for final assignment (with compiler optimization disabled)。
注意:对于大多数编译器，默认情况下为反优化 Debug模式(-O0)。它也是“快速编译”模式，因此非常适合查看代码是否完全可以编译/运行，但是对基准测试毫无用处。最终生成的编译器生成的asm的运行速度取决于硬件，但并没有告诉您任何有关优化代码运行速度的信息。 (例如Adding a redundant assignment speeds up code when compiled without optimization的答案是一些相当微妙的Intel Sandybridge系列存储转发延迟行为，直接由存储/重新加载引起，并且循环计数器上的循环瓶颈在内存中。
请注意，该问题的第一个版本询问的是为什么这样做会使C更快，这被正确地否决了，因为基准测试-O0很愚蠢。当我将其编辑为x86 asm问题时，它才变成一个有趣的问题，该问题很有趣，这是因为asm更大但速度更快，而不是因为它来自gcc -O0，并且进行了任何特定的源更改。)
而且，这甚至都没有提到C++标准库函数，例如std::sort或std::vector::push_back，它们依赖于优化器来内联许多对微小的辅助函数/包装函数的嵌套调用。

编译器如何优化
(我将展示C++代码的转换。请记住，编译器实际上是在转换程序逻辑的内部表示形式，然后生成asm。您可以将转换后的C++视为asm的伪代码，其中i++表示一个x86 inc eax指令之类的东西。大多数C/C++语句可以映射为1条或几条机器指令。因此，这是描述实际编译器生成的asm可能在做什么的逻辑的有用方法，而无需将其实际编写为asm。
不必首先计算从未使用过的结果。 没有副作用的循环可以完全删除。或者可以将分配给全局变量的循环(可观察到的副作用)优化为仅执行最后一次分配。例如

// int gsink;  is a global.  
// "sink" is the opposite of a source: something we dump results into.
for (int i=0 ; i<n ; i++) {
    gsink = i*10;
}

if ( 0 < n ) {      // you might not have noticed that your loop could run 0 times
    gsink = (n-1)*10; // but the compiler isn't allowed to do gsink=0 if n<1
}

volatile int gsink;

int i10 = 0;   // I could have packed this all into a for() loop
int i=0;       // but this is more readable
while (i<n) {
    gsink = i10;
    i10 += 10;
    i++;
}

volatile int gvsink;

void store_n(int n) {
    for(int i=0 ; i<n; i++) {
        gvsink = i*10;
    }
}

store_n(int):          # n in EDI  (x86-64 System V calling convention)
    test    edi, edi
    jle     .L5                   # if(n<=0) goto end

    lea     edx, [rdi+rdi*4]      # edx = n * 5
    xor     eax, eax              # tmp = 0
    add     edx, edx              # edx = n * 10

.L7:                                   # do {
    mov     DWORD PTR gvsink[rip], eax   # gvsink = tmp
    add     eax, 10                      # tmp += 10
    cmp     eax, edx
    jne     .L7                        # } while(tmp != n*10)
.L5:
    rep ret

void store_n(unsigned int n) {
    for(unsigned int i=0 ; i<n; i++) {
        gvsink = i*10;
    }
}

store_n(unsigned int):
    test    edi, edi
    je      .L9            # if (n==0) return;
    xor     edx, edx       # i10 = 0
    xor     eax, eax       # i = 0
.L11:                      # do{
    add     eax, 1         #    i++
    mov     DWORD PTR gvsink[rip], edx
    add     edx, 10        #    i10 += 10
    cmp     edi, eax       
    jne     .L11           # } while(i!=n)
.L9:
    rep ret

i10 = 0;
do {
    gvsink = i10;
    i10 += 10;
} while(--n != 0);

关于c++ - 简单的for()循环基准测试与任何循环绑定(bind)都花费相同的时间，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/50924929/