标签: compiler-optimization

考虑以下两个函数：

void f(int n);

void f(int const n);

从编译器优化的角度来看，后者似乎比前者更好。

然而，从调用者的角度来看，比 .int const n拥有更多的无用信息和更多的精神负担int n。

哪个是更好的做法？

假设我在这样的循环中检查变量.

while( var )
  ;

在这里,VAR必须申报volatile,如果程序是多线程和VAR被多个线程访问.这是一个众所周知的事实.但是,让我们说,我们有类似的东西.

while( var + 1 )
  ;

这还能用volatile吗？我的意思是编译器可能缓存(var + 1)的值吗？换句话说,我问我们是否需要像下面这样编写代码,temp也是一个volatile变量,以确保编译器不会进行缓存.

while( temp )
  temp = var + 1;

为什么Fibonacci递归程序工作这么久？

这是在OCaml:

let rec fib n = if n<2 then n else fib (n-1) + fib (n-2);;

这是在Mathematica:

Fib[n_] := If[n < 2, n, Fib[n - 1] + Fib[n - 2]]

这是在Java中:

public static BigInteger fib(long n) {
    if( n < 2 ) {
        return BigInteger.valueOf(n);
    }
    else {
        return fib(n-1).add(fib(n-2));
    }
}

因为n=100它工作了很长时间,因为,我猜,它会2^100及时跟踪节点树.

虽然只生成100个数字,但它只能消耗100个内存寄存器和100个计算机.

因此,可以优化执行.

这项任务是什么以及如何解决？由于Mathematica中没有实现解决方案,因此可能不存在.关于此事的研究怎么样？

例如,哪些更快:

if(object.GetMemberX().IsSomething())
{
    Store(object.GetMemberX());
    object.GetMemberX().FlagSomething();
}

要么

typeX x = object.GetMemberX();
if(typeX.IsSomething())
{
    Store(x);
    x.FlagSomething();
}

我想如果GetMemberX()在第一个例子中返回一个指针或一个引用,编译器就无法优化掉两个调用,因为它不能保证返回的指针/引用对于每个调用都是相同的？

但在第二个例子中我存储它？

如果这是真的,它是否只适用于返回指针/引用的方法？如果我的方法按值返回它们会受益于/受到不同调用的阻碍吗？

在C语言中,对于if语句,有时我们可以看到测试'值放在要测试的变量之前,这可能带来一些优化(GCC编译器),但是哪一个？(但这会降低我的可读性).

例:

if ( 10 == val) {}

谢谢,

我是ARM平台的新手.

下面的代码已用于函数中,用于找出一些复数样本的共轭乘法并将其滑动到某些样本.

这段代码在linux 12.04版本的本机编译器中正常工作.在ARM中运行相同的代码时,它不会执行该功能.它只是从代码运行中退出.

#include<stdio.h>

int main()
{
    float aa[12]={1,1,1,1,1,1,1,1,1,1,1,1};
    float *x=aa,*y=x+6,real=0,imag=0;

    fn_ComplexMultiply_addthem(x,y,6,&real,&imag);

    printf("real value = %f\n",real);
    printf("real value = %f\n",imag);
}

void fn_ComplexMultiply_addthem(float *x, float *y, float len, float *re, float *im)
{
    int j;

    for( j=0; j<len; j+=2)
    {
        *re += (x[j]*(y[j]));
        *re -= (x[j+1]*(-y[j+1]));
        *im += (x[j]*(-y[j+1]));
        *im += (x[j+1]*(y[j]));
    }
}

我无法理解它的原因.每个指针指向一些值,然后它应该给我结果,无论什么可能是正确的.相反,它只是退出模拟.

是否会出现诸如堆栈或其他内存等其他问题？请帮我调试一下.

不同的C ++功能的编译时间是多少？我有兴趣选择正确的方法来在我的库头文件中实现一些通用代码，并且我想花一些时间为图书馆用户考虑。粗略和/或相对的数字就可以了。

我对以下情况特别感兴趣：

• 增加班级专长
• 添加constexpr函数（仅声明）
• 添加最简单的constexpr函数（如{ return true; }）
• 在编译时执行最简单的constexpr函数。
• 实例化类模板
• 实例化模板别名
• 实例化变量模板
• 找到正确的模板类专业化
• 通过ADL找到合适的功能

PS：请不要谈论我过早的优化。无论如何，有关编译时间的信息将对C ++开发人员很有趣。

更新：阐明了我正在优化的代码在库头文件中，因此其编译时间对于库用户而言绝对重要。

更新：改写该问题以免引起别人的疑问。

当使用 gcc 和最大优化（GCC 11.1.0，gcc -std=c11 -O3）编译这两个片段时，我希望获得完全相同的可执行文件，因为%2和&1操作是等效的。objdump但是，在用 反汇编之后，两个目标文件有所不同。输出如下所示。

和

int main(int argc, char **argv){
   return argc & 1;
}

0000000000001020 <main>:
    1020:       89 f8                   mov    %edi,%eax
    1022:       83 e0 01                and    $0x1,%eax
    1025:       c3                      ret    
    1026:       66 2e 0f 1f 84 00 00    cs nopw 0x0(%rax,%rax,1) 

模数

0000000000001020 <main>:
    1020:       89 f8                   mov    %edi,%eax
    1022:       83 e0 01                and    $0x1,%eax
    1025:       c3                      ret    
    1026:       66 2e 0f 1f 84 …

要为特定 CPU 构建具有最佳优化的二进制文件，如何设置 C/C++ 编译器选项？例如，当功能可用时，尝试利用 MMX/3DNow!/SSE/SSE2/SSE3 等 CPU 功能。

正如标题所说,它很容易被描述.

每次我可以将两个单独的语句放在一个块中时,我就会想到这个问题.特别是当我编写像NP完全问题的CPU成本问题时.

是否有必要将两个单独的陈述合并在一起？