相关疑难解决方法(0)

我正在用C++做一些性能关键的工作,我们目前正在使用整数计算来解决本质上浮点的问题,因为"它更快".这会导致很多令人烦恼的问题,并增加了许多烦人的代码.

现在,我记得在大约386天的时间里读到关于浮点计算如此缓慢的情况,我相信(IIRC)有一个可选的共同进程.但是现在肯定会有指数级更复杂和更强大的CPU,如果进行浮点或整数计算,它在"速度"上没有区别吗？特别是因为与导致管道停滞或从主存储器中取出某些东西相比,实际计算时间很短？

我知道正确的答案是在目标硬件上进行基准测试,测试它的好方法是什么？我编写了两个很小的C++程序,并将它们的运行时间与Linux上的"时间"进行了比较,但实际的运行时间变化太大(无法帮助我在虚拟服务器上运行).没有花一整天的时间来运行数百个基准测试,制作图表等等,我可以做些什么来合理地测试相对速度？任何想法或想法？我完全错了吗？

我使用的程序如下,它们不相同:

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <time.h>

int main( int argc, char** argv )
{
    int accum = 0;

    srand( time( NULL ) );

    for( unsigned int i = 0; i < 100000000; ++i )
    {
        accum += rand( ) % 365;
    }
    std::cout << accum << std::endl;

    return 0;
}

计划2:

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <time.h>

int main( int argc, char** argv )
{

    float accum = 0;
    srand( time( NULL …

在阅读有关汇编程序的文章时,我经常遇到人们在写文件时他们推送处理器的某个寄存器并稍后再次弹出它以恢复它之前的状态.

• 怎么能推一个寄存器？它在哪里推？为什么需要这个？
• 这可归结为单处理器指令还是更复杂？

我发现了这个有趣且功能强大的工具IACA(英特尔架构代码分析器),但我无法理解它.我能用它做什么,它的局限性是什么？我该怎么做:

• 用它来分析C或C++中的代码？
• 用它来分析x86汇编程序中的代码？

有没有人见过任何关于restrictgcc/g ++实际使用C/C++ 关键字的数字/分析是否能在现实中提供任何显着的性能提升(而不仅仅是在理论上)？

我已经阅读了各种推荐/贬低其使用的文章,但我没有碰到任何实际数字,实际上证明了任何一方的论点.

编辑

我知道这restrict不是C++的正式部分,但它得到了一些编译器的支持,我读过Christer Ericson的一篇论文,强烈推荐使用它.

下面的 square 实现会产生一系列 cmp/je 语句，就像我期望的链式 if 语句一样：

int square(int num) {
    if (num == 0){
        return 0;
    } else if (num == 1){
        return 1;
    } else if (num == 2){
        return 4;
    } else if (num == 3){
        return 9;
    } else if (num == 4){
        return 16;
    } else if (num == 5){
        return 25;
    } else if (num == 6){
        return 36;
    } else if (num == 7){
        return 49;
    } else {
        return num * num; …

我正在寻找最快/最节省空间的方法，将 64 位寄存器减少为 32 位寄存器，仅保留 64 位寄存器的零/非零状态。

我目前适用于所有值的最佳想法是popcntq
（1c tput，主流英特尔上的 3c 延迟，5 字节代码大小）：

// rax is either zero or non-zero
popcntq %rax, %rax
// eax will be zero if rax was zero, otherwise it will be non-zero

注意：直接使用 32 位是行不通的eax：如果rax说 的2^61零/非零状态eax与 的不同rax

有没有更好的巧妙方法？

我正在考虑对装配有一些非常基本的了解.我目前的目标很简单:在使用-S开关为x86/x86-64编译C/C++时,对GCC汇编器输出有非常基本的了解.

足以做一些简单的事情,例如查看单个函数并验证GCC是否优化了我希望消失的东西.

有没有人知道一个真正简洁的汇编介绍,与GCC相关,特别是为了阅读的目的,以及任何随便阅读汇编的人都应该知道的最重要的指令清单？

现代x86 CPU将传入的指令流分解为微操作(uops ¹),然后在输入准备就绪时将这些uop 无序调度.虽然基本思路很清楚,但我想了解准备好指令的具体细节,因为它会影响微优化决策.

例如,采取以下玩具循环²:

top:
lea eax, [ecx + 5]
popcnt eax, eax
add edi, eax
dec ecx
jnz top

这基本上实现了循环(具有以下对应关系:) eax -> total, c -> ecx:

do {
  total += popcnt(c + 5);
} while (--c > 0);

通过查看uop细分,依赖链延迟等,我熟悉优化任何小循环的过程.在上面的循环中,我们只有一个携带的依赖链:dec ecx.环路(前三指令lea,imul,add)是开始新鲜每个环一个依赖关系链的一部分.

决赛dec和jne融合.因此,我们总共有4个融合域uop,以及一个仅循环携带的依赖链,延迟为1个周期.因此,基于该标准,似乎循环可以在1个周期/迭代时执行.

但是,我们也应该关注港口压力:

• 在lea能够在端口1和5执行
• popcnt可以在端口1上执行
• 在add可以在端口0,1,5和6执行
• 预测采用jnz在端口6上执行

因此,要进行1次循环/迭代,您几乎需要执行以下操作:

• popcnt 必须在端口1上执行(它可以执行的唯一端口)
• 在lea 必须 …

我是指令优化的新手.

我对一个简单的函数dotp进行了简单的分析,该函数用于获取两个浮点数组的点积.

C代码如下:

float dotp(               
    const float  x[],   
    const float  y[],     
    const short  n      
)
{
    short i;
    float suma;
    suma = 0.0f;

    for(i=0; i<n; i++) 
    {    
        suma += x[i] * y[i];
    } 
    return suma;
}

我用昂纳雾在网络上提供的测试框架testp.

在这种情况下使用的数组是对齐的:

int n = 2048;
float* z2 = (float*)_mm_malloc(sizeof(float)*n, 64);
char *mem = (char*)_mm_malloc(1<<18,4096);
char *a = mem;
char *b = a+n*sizeof(float);
char *c = b+n*sizeof(float);

float *x = (float*)a;
float *y = (float*)b;
float *z = (float*)c;

然后我调用函数dotp,n = 2048,repeat …

我正在编写一个带有x86后端的JIT编译器,并且随时学习x86汇编器和机器代码.大约20年前我使用ARM汇编程序,并对这些体系结构之间的成本模型差异感到惊讶.

具体来说,内存访问和分支在ARM上很昂贵,但在x86上等效的堆栈操作和跳转很便宜.我相信现代x86 CPU比ARM内核做更多的动态优化,我发现很难预测它们的影响.

编写x86汇编程序时要记住什么是好的成本模型？哪些指令组合便宜又昂贵？

例如,如果它总是生成用于加载整数或跳转到偏移的长格式,即使整数很小或偏移量接近但这会影响性能,我的编译器会更简单吗？

我还没有做任何浮动点,但我很快就会接受它.普通代码和浮动代码之间的相互作用有什么不明显的吗？

我知道有很多关于x86优化的参考文献(例如Michael Abrash),但我有一个预感,而不是几年前的任何东西都不适用于现代的x86 CPU,因为它们最近发生了很大的变化.我对么？