我在从dmckee的答案中找到一个链接后开发了这个答案，但它采用了与他/她的答案不同的方法。
来自GCC的Function Attributes文档提到：
noinline此函数属性可防止考虑将函数内联。如果函数没有副作用，则存在内联以外的优化，会导致函数调用被优化掉，尽管函数调用是实时的。若要防止此类调用被优化掉，请将asm ("");
这给了我一个有趣的想法.我尝试在内部循环中添加一个空的汇编代码，而不是在内部循环中添加nop指令，如下所示：

unsigned char i, j;
j = 0;
while(--j) {
    i = 0;
    while(--i)
        asm("");
}

字符串
这个循环没有被优化，也没有插入额外的nop指令。
更重要的是，如果你使用volatile，gcc会将这些变量存储在RAM中，并添加一堆ldd和std来将它们复制到临时寄存器中。另一方面，这种方法不使用volatile，也不会产生这样的开销。

• 更新：* 如果你使用-ansi或-std编译代码，你必须用__asm__替换asm关键字，作为described in GCC documentation。

此外，如果 *assembly语句必须在我们放置它的位置执行（即不能作为优化移出循环），则也可以使用__asm__ __volatile__("")。

将i和j变量解析为volatile。这将阻止编译器优化包含这些变量的代码。

unsigned volatile char i, j;

字符串

空的__asm__语句是不够的：最好使用数据依赖关系

就像这样：

文件 main.c

int main(void) {
    unsigned i;
    for (i = 0; i < 10; i++) {
        __asm__ volatile("" : "+g" (i) : :);
    }
}

字符串
编译和反汇编：

gcc -O3 -ggdb3 -o main.out main.c
gdb -batch -ex 'disas main' main.out

型
输出量：

0x0000000000001040 <+0>:     xor    %eax,%eax
   0x0000000000001042 <+2>:     nopw   0x0(%rax,%rax,1)
   0x0000000000001048 <+8>:     add    $0x1,%eax
   0x000000000000104b <+11>:    cmp    $0x9,%eax
   0x000000000000104e <+14>:    jbe    0x1048 <main+8>
   0x0000000000001050 <+16>:    xor    %eax,%eax
   0x0000000000001052 <+18>:    retq

型
我相信这是健壮的，因为它在循环变量i上放置了一个显式的数据依赖项，如：Enforcing statement order in C++所示，并产生了所需的循环：
这就把i标记为内联汇编的输入和输出，那么，内联汇编对于GCC来说就是一个黑盒子，GCC不知道它是如何修改i的，所以我认为这一点真的无法优化掉。
如果我对一个空的__asm__执行相同的操作，如下所示：

文件 * 不正确.c*

int main(void) {
    unsigned i;
    for (i = 0; i < 10; i++) {
        __asm__ volatile("");
    }
}

型
它看起来完全消除了循环和输出：

0x0000000000001040 <+0>:     xor    %eax,%eax
   0x0000000000001042 <+2>:     retq

型
另请注意，__asm__("")和__asm__ volatile("")应该相同，因为没有输出操作数：The difference between asm, asm volatile and clobbering memory
如果我们将其替换为：

__asm__ volatile("nop");

型
其产生：

0x0000000000001040 <+0>:     nop
   0x0000000000001041 <+1>:     nop
   0x0000000000001042 <+2>:     nop
   0x0000000000001043 <+3>:     nop
   0x0000000000001044 <+4>:     nop
   0x0000000000001045 <+5>:     nop
   0x0000000000001046 <+6>:     nop
   0x0000000000001047 <+7>:     nop
   0x0000000000001048 <+8>:     nop
   0x0000000000001049 <+9>:     nop
   0x000000000000104a <+10>:    xor    %eax,%eax
   0x000000000000104c <+12>:    retq

型
我们可以看到，GCC在本例中只是loop unrollednop循环，因为该循环足够小。
因此，如果您依赖于一个空的__asm__，您将依赖于难以预测的GCC二进制大小/速度权衡，如果以最佳方式应用，应该总是会删除代码大小为零的空__asm__ volatile("");的循环。

noinline忙碌循环功能

如果在编译时不知道循环的大小，那么完全展开是不可能的，但是GCC仍然可以决定以块的形式展开，这将使延迟不一致。
将其与Denilson's answer结合在一起，一个忙碌循环函数可以写成：

void __attribute__ ((noinline)) busy_loop(unsigned max) {
    for (unsigned i = 0; i < max; i++) {
        __asm__ volatile("" : "+g" (i) : :);
    }
}
int main(void) {
    busy_loop(10);
}

型
其在以下位置拆卸：

Dump of assembler code for function busy_loop:
   0x0000000000001140 <+0>:     test   %edi,%edi
   0x0000000000001142 <+2>:     je     0x1157 <busy_loop+23>
   0x0000000000001144 <+4>:     xor    %eax,%eax
   0x0000000000001146 <+6>:     nopw   %cs:0x0(%rax,%rax,1)
   0x0000000000001150 <+16>:    add    $0x1,%eax
   0x0000000000001153 <+19>:    cmp    %eax,%edi
   0x0000000000001155 <+21>:    ja     0x1150 <busy_loop+16>
   0x0000000000001157 <+23>:    retq   
End of assembler dump.
Dump of assembler code for function main:
   0x0000000000001040 <+0>:     mov    $0xa,%edi
   0x0000000000001045 <+5>:     callq  0x1140 <busy_loop>
   0x000000000000104a <+10>:    xor    %eax,%eax
   0x000000000000104c <+12>:    retq   
End of assembler dump.

型
这里需要使用volatile将程序集标记为可能有副作用，因为在本例中我们有一个输出变量。
双循环版本可以是：

void __attribute__ ((noinline)) busy_loop(unsigned max, unsigned max2) {
    for (unsigned i = 0; i < max2; i++) {
        for (unsigned j = 0; j < max; j++) {
            __asm__ volatile ("" : "+g" (i), "+g" (j) : :);
        }
    }
}
int main(void) {
    busy_loop(10, 10);
}

型
GitHub upstream的一个。
相关主题：

• Endless loop in C/C++的
• Best way to implement busy loop?
• 在C++中强制执行语句顺序

在Ubuntu 19.04和GCC 8.3.0中进行了测试。

我不知道为什么还没有提到这种方法是完全错误的，很容易被编译器升级等破坏。确定你想要等待的时间值并旋转轮询当前时间直到超过所需的值会更有意义。在x86上，你可以使用rdtsc来实现这个目的，但更可移植的方法是调用clock_gettime（或非POSIX操作系统的变体）来获取时间。当前的x86_64 Linux甚至会避免clock_gettime的系统调用，而在内部使用rdtsc。或者，如果您可以处理系统调用的成本，只需使用clock_nanosleep来开始.

我不知道编译器的AVR版本是否支持full set of #pragma s（链接中有趣的内容都来自GCC版本4.4），但这是您通常会开始的地方。

对我来说，在GCC 4.7.0上，空的汇编代码无论如何都是用-O3优化的（我没有尝试用-O2）。在 register 或 volatile 中使用i++会导致很大的性能损失（在我的情况下）。
我链接了另一个空函数，编译器在编译“主程序”时看不到它。
基本上是这样的：
我创建了“helper.c”，并声明了这个函数（空函数）：

void donotoptimize(){}

字符串
然后编译gcc helper.c -c -o helper.o，

while (...) { donotoptimize();}

型
并通过gcc my_benchmark.cc helper.o连接。
这给了我最好的结果（从我的信念，没有开销，但我不能测试，因为我的程序将无法工作没有它：））
我认为它也应该能在ICC上工作。如果你启用了链接优化，也许不行，但在GCC上可以。

把volatile asm放在这里应该会有帮助。你可以在这里阅读更多：

• Problems with reordering code*（第一个字符）

如果你在Windows上工作，你甚至可以尝试将代码放在pragmas下，如下所述：
https://www.securecoding.cert.org/confluence/display/cplusplus/MSC06-CPP.+Be+aware+of+compiler+optimization+when+dealing+with+sensitive+data的

把这个循环放在一个单独的.c文件中，不要优化那个文件。更好的是，用汇编程序编写这个例程，然后从C调用它。无论哪种方式，优化器都不会参与进来。
我有时会做volatile的事情，但通常会创建一个asm函数，它只是返回对该函数的put调用，优化器会使 for/while 循环紧密，但它不会优化它，因为它必须对dummy函数进行所有调用。Denilson Sá的nop答案做同样的事情，但更紧密。

你也可以使用register关键字。使用register声明的变量存储在CPU寄存器中。
在您的案例中：

register unsigned char i, j;
j = 0;
while(--j) {
    i = 0;
    while(--i);
}

字符串