如何防止GCC优化繁忙的等待循环？

我想为Atmel AVR微控制器编写C代码固件。我将使用GCC进行编译。另外，我想启用编译器优化（-Os或-O2），因为我没有理由不启用它们，并且它们可能比手动编写程序集更快地产生更好的组装方式。

但是我想要一小段未优化的代码。我想将函数的执行延迟一段时间，因此我想编写一个空循环，以浪费时间。无需精确，只需等待一段时间。

/* How to NOT optimize this, while optimizing other code? */
unsigned char i, j;
j = 0;
while(--j) {
    i = 0;
    while(--i);
}

由于AVR内存访问是慢了很多，我想i和j被关在CPU寄存器。

更新：我刚刚从AVR Libc中找到util / delay.h和util / delay_basic.h。尽管大多数时候使用这些功能可能是一个更好的主意，但这个问题仍然有效且有趣。

相关问题：

• 如何防止gcc在C语言中优化某些语句？
• 有没有办法告诉GCC不要优化特定代码？
• 如何不优化-愚蠢功能的机制

我在查看了dmckee的答案的链接后开发了此答案，但是采用的方法与他/她的答案不同。

GCC的功能属性文档中提到：

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__，如GCC文档中描述。

另外，__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如以下建议：在C ++中强制执行语句顺序并生成所需的循环：

这标记i为内联汇编的输入和输出。然后，内联汇编对于GCC来说是一个黑匣子，它不知道它是如何修改的i，因此我认为确实无法对其进行优化。

如果我对空白执行相同操作__asm__：

坏

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

它似乎完全消除了循环并输出：

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

还要注意，__asm__("")并且__asm__ volatile("")应该相同，因为没有输出操作数：asm，asm volatile和破坏内存之间的区别

如果我们将其替换为：

__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只是循环展开了nop循环，因为循环足够小。

因此，如果您依赖一个Empty __asm__，您将很难预测GCC二进制大小/速度的折衷，如果以最佳方式应用，它将始终删除__asm__ volatile("");代码大小为零的empty的循环。

noinline 忙循环功能

如果在编译时不知道循环大小，则不可能完全展开，但是GCC仍可以决定分块展开，这会使您的延迟不一致。

将其与Denilson的答案一起，可以将繁忙循环函数编写为：

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上游。

相关主题：

• C / C ++中的无限循环
• 实施繁忙循环的最佳方法？
• 在C ++中执行语句顺序

已在Ubuntu 19.04，GCC 8.3.0中测试。

我不确定为什么还没有提到它，因为这种方法完全被误导，很容易被编译器升级等破坏。确定要等待的时间值并旋转轮询当前值更有意义。直到超过所需值的时间。在x86上，您可以rdtsc用于此目的，但是更可移植的方法是致电clock_gettime（或非POSIX OS的变体）来获取时间。当前的x86_64 Linux甚至会避免在内部clock_gettime使用syscall rdtsc。或者，如果您可以处理syscall的费用，则只需使用clock_nanosleep...

我不知道该编译器的avr版本是否支持s的全集#pragma（链接中所有有趣的内容都源于gcc 4.4版），但这通常是您开始的地方。

对我而言，在GCC 4.7.0上，无论如何都使用-O3来优化空的asm（不尝试使用-O2）。并且在寄存器或volatile中使用i ++会导致很大的性能损失（在我的情况下）。

我所做的是与另一个空函数链接，编译“主程序”时编译器无法看到该函数

基本上是这样的：

使用此函数（空函数）声明创建的“ helper.c”

void donotoptimize(){}

然后编译gcc helper.c -c -o helper.o 然后

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

并通过链接gcc my_benchmark.cc helper.o。

这给了我最好的结果（并且据我所知，根本没有任何开销，但是无法测试，因为没有它我的程序将无法工作:)）

我认为它也应与icc一起使用。如果启用链接优化，可能就不行，但是使用gcc可以。

将该循环放在单独的.c文件中，不要优化该文件。最好用汇编器编写该例程并从C调用该例程，无论哪种方式，优化器都不会参与。

我有时会做一些易变的事情，但通常会创建一个asm函数，该函数只是返回对该函数的调用，优化器将使for / while循环变紧，但由于必须对虚拟函数进行所有调用，因此它不会对其进行优化。DenilsonSá的nop回答做了同样的事情，但更加严格...

放置挥发性的asm应该会有所帮助。您可以在这里阅读更多内容：

http://www.nongnu.org/avr-libc/user-manual/optimization.html

如果您使用的是Windows，甚至可以尝试将代码置于编译指示下，如下所述：

https://www.securecoding.cert.org/confluence/display/cplusplus/MSC06-CPP.+要+意识到+ of +编译器+优化+何时+使用+敏感+数据

希望这可以帮助。

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

在您的情况下：

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