是否将参数加载到缓存中以获取空函数？

Question

我知道C ++编译器优化了空（静态）函数。

基于这些知识，我编写了一段代码，每当我定义一些标识符时（使用编译器的-D选项），都应该优化掉。考虑以下虚拟示例：

#include <iostream>

#ifdef NO_INC

struct T {
    static inline void inc(int& v, int i) {}
};

#else

struct T {
    static inline void inc(int& v, int i) {
        v += i;
    }
};

#endif

int main(int argc, char* argv[]) {
    int a = 42;

    for (int i = 0; i < argc; ++i)
        T::inc(a, i);

    std::cout << a;
}

所需的行为如下：每当定义NO_INC标识符（编译时使用-DNO_INC），所有对T::inc(...)的调用都应该被优化掉（由于空函数体）。否则，对T::inc(...)的调用应该触发某个给定值i的增量。

我有两个问题：

1. 我的假设是正确的，当我指定T::inc(...)选项时，调用-DNO_INC不会对性能产生负面影响，因为对空函数的调用是优化的吗？
2. 我想知道当调用a时，变量（i和T::inc(a, i)）是否仍然加载到缓存中（假设它们还没有），尽管函数体是空的。

谢谢你的建议！

Answer 1

Compiler Explorer是一个非常有用的工具，用于查看生成的程序的程序集，因为没有其他方法可以确定编译器是否优化了某些东西。 Demo。

随着实际递增，你的main看起来像：

main:                                   # @main
        push    rax
        test    edi, edi
        jle     .LBB0_1
        lea     eax, [rdi - 1]
        lea     ecx, [rdi - 2]
        imul    rcx, rax
        shr     rcx
        lea     esi, [rcx + rdi]
        add     esi, 41
        jmp     .LBB0_3
.LBB0_1:
        mov     esi, 42
.LBB0_3:
        mov     edi, offset std::cout
        call    std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
        xor     eax, eax
        pop     rcx
        ret

正如您所看到的，编译器完全内联对T::inc的调用并直接进行递增。

对于一个空的T::inc你得到：

main:                                   # @main
        push    rax
        mov     edi, offset std::cout
        mov     esi, 42
        call    std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
        xor     eax, eax
        pop     rcx
        ret

编译器优化了整个循环！

我的假设是正确的，当我指定t.inc(...)选项时，调用-DNO_INC不会对性能产生负面影响，因为对空函数的调用是优化的吗？

是。

如果我的假设成立，它是否适用于更复杂的函数体（在#else分支中）？

不，对于“复杂”的某些定义。编译器使用启发式方法来确定是否值得内联函数，并将其决策基于此而不是其他任何内容。

我想知道当调用a时，变量（i和t.inc(a, i)）是否仍然加载到缓存中（假设它们还没有），尽管函数体是空的。

不，如上所述，循环甚至不存在。

Answer 2

我的假设是正确的，当我指定-DNO_INC选项时，调用t.inc（...）不会对性能产生负面影响，因为对空函数的调用是优化的吗？如果我的假设成立，它是否适用于更复杂的函数体（在#else分支中）？

你是对的。我在compiler explorer中修改了你的例子（即删除了使程序集混乱的cout），使其更加明显。

编译器优化了所有内容并输出

main:                                   # @main
        movl    $42, %eax
        retq

在eax中只有42个含铅并返回。

但是，对于更复杂的情况，需要更多指令来计算返回值。 See here

main:                                   # @main
        testl   %edi, %edi
        jle     .LBB0_1
        leal    -1(%rdi), %eax
        leal    -2(%rdi), %ecx
        imulq   %rax, %rcx
        shrq    %rcx
        leal    (%rcx,%rdi), %eax
        addl    $41, %eax
        retq
.LBB0_1:
        movl    $42, %eax    
        retq

我想知道当调用t.inc（a，i）时，变量（a和i）是否仍然加载到缓存中（假设它们还没有），尽管函数体是空的。

只有在编译器无法推断它们未被使用时才会加载它们。请参阅编译器资源管理器的第二个示例。

顺便说一句：您不需要创建T的实例（即T t;）来调用类中的静态函数。这是在挫败目的。把它称为T::inc(...) rahter比t.inc(...)。

Answer 3

因为使用了inline关键字，所以可以安全地假设1.使用这些函数不应该对性能产生负面影响。

运行代码

g ++ -c -Os -g

objdump -S

证实了这一点;提取物：

int main(int argc, char* argv[]) {
    T t;
    int a = 42;
    1020:   b8 2a 00 00 00          mov    $0x2a,%eax
    for (int i = 0; i < argc; ++i)
    1025:   31 d2                   xor    %edx,%edx
    1027:   39 fa                   cmp    %edi,%edx
    1029:   7d 06                   jge    1031 <main+0x11>
        v += i;
    102b:   01 d0                   add    %edx,%eax
    for (int i = 0; i < argc; ++i)
    102d:   ff c2                   inc    %edx
    102f:   eb f6                   jmp    1027 <main+0x7>
        t.inc(a, i);
    return a;
}
    1031:   c3                      retq

（为了更好的可读性，我用返回替换了cout）