相关疑难解决方法(0)

我听说有英特尔在线书籍描述了特定汇编指令所需的CPU周期,但我无法找到它(经过努力).有人能告诉我如何找到CPU周期吗？

下面是一个例子,在下面的代码中,mov/lock是1个CPU周期,xchg是3个CPU周期.

// This part is Platform dependent!
#ifdef WIN32
inline int CPP_SpinLock::TestAndSet(int* pTargetAddress, 
                                              int nValue)
{
    __asm
    {
        mov edx, dword ptr [pTargetAddress]
        mov eax, nValue
        lock xchg eax, dword ptr [edx]
    }
    // mov = 1 CPU cycle
    // lock = 1 CPU cycle
    // xchg = 3 CPU cycles
}

#endif // WIN32

顺便说一句:这是我发布的代码的URL:http://www.codeproject.com/KB/threads/spinlocks.aspx

• 代码1:

  vzeroall
  mov             rcx, 1000000
  startLabel1:
  vfmadd231ps     ymm0, ymm0, ymm0
  vfmadd231ps     ymm1, ymm1, ymm1
  vfmadd231ps     ymm2, ymm2, ymm2
  vfmadd231ps     ymm3, ymm3, ymm3
  vfmadd231ps     ymm4, ymm4, ymm4
  vfmadd231ps     ymm5, ymm5, ymm5
  vfmadd231ps     ymm6, ymm6, ymm6
  vfmadd231ps     ymm7, ymm7, ymm7
  vfmadd231ps     ymm8, ymm8, ymm8
  vfmadd231ps     ymm9, ymm9, ymm9
  vpaddd          ymm10, ymm10, ymm10
  vpaddd          ymm11, ymm11, ymm11
  vpaddd          ymm12, ymm12, ymm12
  vpaddd          ymm13, ymm13, ymm13
  vpaddd          ymm14, ymm14, ymm14
  dec             rcx
  jnz             startLabel1
  

  Run Code Online (Sandbox Code Playgroud)

• 代码2:

  vzeroall
  mov             rcx, 1000000
  startLabel2:
  vmulps          ymm0, ymm0, ymm0 …

  Run Code Online (Sandbox Code Playgroud)

我是指令优化的新手.

我对一个简单的函数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 …

当试图理解汇编(启用编译器优化)时,我看到这种行为:

这样一个非常基本的循环

outside_loop;
while (condition) {
     statements;
}

经常被编译成(伪代码)

    ; outside_loop
    jmp loop_condition    ; unconditional
loop_start:
    loop_statements
loop_condition:
    condition_check
    jmp_if_true loop_start
    ; outside_loop

但是,如果未打开优化,则会编译为通常可理解的代码:

loop_condition:
    condition_check
    jmp_if_false loop_end
    loop_statements
    jmp loop_condition  ; unconditional
loop_end:

根据我的理解,编译后的代码更像是这样的:

goto condition;
do {
    statements;
    condition:
}
while (condition_check);

我看不到巨大的性能提升或代码可读性提升,为什么经常出现这种情况呢？是否有此循环样式的名称,例如"尾随条件检查"？

我一直看到人们声称MOV指令可以在x86中免费,因为寄存器重命名.

对于我的生活,我无法在一个测试用例中验证这一点.每个测试用例我尝试揭穿它.

例如,这是我用Visual C++编译的代码:

#include <limits.h>
#include <stdio.h>
#include <time.h>

int main(void)
{
    unsigned int k, l, j;
    clock_t tstart = clock();
    for (k = 0, j = 0, l = 0; j < UINT_MAX; ++j)
    {
        ++k;
        k = j;     // <-- comment out this line to remove the MOV instruction
        l += j;
    }
    fprintf(stderr, "%d ms\n", (int)((clock() - tstart) * 1000 / CLOCKS_PER_SEC));
    fflush(stderr);
    return (int)(k + j + l);
}

这为循环生成以下汇编代码(随意生成这个你想要的;你显然不需要Visual C++):

LOOP:
    add edi,esi
    mov …

有人可以解释英特尔内部指南中给出的延迟和吞吐量值吗？

我是否正确理解延迟是指令运行所需的时间单位,吞吐量是每个时间单位可以启动的指令数量？

如果我的定义是正确的,为什么某些指令的延迟在较新的CPU版本上更高(例如mulps)？

根据英特尔内部指南,

• vxorpd ymm, ymm, ymm:计算a和b中打包的双精度(64位)浮点元素的按位XOR,并将结果存储在dst中.
• vpxor ymm, ymm, ymm:计算a和b中256位(表示整数数据)的按位XOR,并将结果存储在dst中.

两者有什么区别？在我看来,两个指令都会对ymm寄存器的所有256位执行按位异或.如果我使用vxorpd整数数据会有任何性能损失(反之亦然)？

在下面突出显示的行中更改add为可adc显着提高性能。我觉得这很违反直觉，因为add有更多的端口要执行，而且它不依赖于标志。

CPU：英特尔 i7-9750H（Coffee Lake）。
UOPS_ISSUED.ANY add= ~2.87 uops /cycle。
UOPS_ISSUED.ANY adc= ~3.47 uops /cycle。
在这两种情况下，退休插槽是 98.5% 的 uops。

它反映在基准时间上，add版本要慢得多。

如果有人能帮助我理解为什么add变慢，我将不胜感激？我可以提供更多指标，只是不知道要寻找什么。

# Code to multiply large integer by a qword.
# RSI = input large integer (qword array).
# RDI = output large integer (qword array).
# RDX = qword to multiply the large integer by.
# ECX = number of 32-byte blocks to process (i.e. qwords …

我希望能够手动预测任意算术的长度(即没有分支或内存,尽管这也很好)x86-64汇编代码将采用特定的体系结构,考虑到指令重新排序,超标量,延迟,消费者价格指数等

什么/描述必须遵循的规则才能实现这一目标？

我想我已经找到了一些初步规则,但是我没有找到任何关于将任何示例代码分解为这个详细程度的引用,所以我不得不做一些猜测.(例如,英特尔优化手册甚至几乎没有提到指令重新排序.)

至少,我正在寻找(1)确认每条规则是正确的,或者是每条规则的正确陈述,以及(2)我可能忘记的任何规则的列表.

• 每个循环发出尽可能多的指令,从当前循环开始按顺序开始,并且可能与重新排序缓冲区大小一样远.
• 如果出现以下情况,可以在给定周期发出指令:
  • 没有影响其操作数的指令仍在执行中.和:
  • 如果它是浮点指令,则它之前的每个浮点指令都被发出(浮点指令具有静态指令重新排序).和:
  • 该循环有一个功能单元可用于该指令.每个(？)功能单元是流水线的,这意味着它可以在每个周期接受1个新指令,并且对于给定功能类的CPI,总功能单元的数量是1/CPI(这里模糊不清:可能是例如addps并且subps使用相同的功能) unit？我如何确定？).和:
  • 4此循环已经发出少于超标量宽度(通常)指令的数量.
• 如果不能发出指令,则处理器不会发出任何称为"停顿"的条件.

例如,请考虑以下示例代码(计算交叉产品):

shufps   xmm3, xmm2, 210
shufps   xmm0, xmm1, 201
shufps   xmm2, xmm2, 201
mulps    xmm0, xmm3
shufps   xmm1, xmm1, 210
mulps    xmm1, xmm2
subps    xmm0, xmm1

我试图预测Haswell的延迟看起来像这样:

; `mulps`  Haswell latency=5, CPI=0.5
; `shufps` Haswell latency=1, CPI=1
; `subps`  Haswell latency=3, CPI=1

shufps   xmm3, xmm2, 210   ; cycle  1
shufps   xmm0, xmm1, 201   ; cycle  2
shufps   xmm2, xmm2, 201   ; …

我试图从数组中包装一个带有32个字符的__m256i变量,并由indices指定.这是我的代码:

char array[];         // different array every time.
uint16_t offset[32];  // same offset reused many times


_mm256_set_epi8(array[offset[0]], array[offset[1]], array[offset[2]], array[offset[3]], array[offset[4]], array[offset[5]], array[offset[6]], array[offset[7]],
      array[offset[8]],array[offset[9]],array[offset[10]],array[offset[11]], array[offset[12]], array[offset[13]], array[offset[14]], array[offset[15]], 
      array[offset[16]],array[offset[17]], array[offset[18]], array[offset[19]], array[offset[20]], array[offset[21]], array[offset[22]], array[offset[23]], 
      array[offset[24]],array[offset[25]],array[offset[26]], array[offset[27]], array[offset[28]], array[offset[29]], array[offset[30]],array[offset[31]])

使用相同的偏移和不同的数组将多次调用此函数.但根据我的测试,我不认为它是最佳的.有什么想法改进吗？