specpoline

specpoline

关注
发信
关注(28)粉丝(399)

assembly - 为什么这种谱线在Kaby湖上不起作用？

我正在尝试在specpoline (cfr. Henry Wong)上创建一个Kabe lake 7600U，正在运行CentOS 7。
完整的测试存储库可在GitHub上找到。
我的specpoline版本如下(cfr. spec.asm):

specpoline:
        ;Long dependancy chain
        fld1
        TIMES 4 f2xm1
        fcos
        TIMES 4 f2xm1
        fcos
        TIMES 4 f2xm1

        %ifdef ARCH_STORE
            mov DWORD [buffer], 241     ;Store in the first line
        %endif

        add rsp, 8
        ret
此版本与黄宏Henry的版本不同，其流程被转移到建筑路径中。当原始版本使用固定地址时，我将目标传递到堆栈中。
这样，add rsp, 8将删除原始的返回地址并使用人工地址。
在函数的第一部分中，我使用一些旧的FPU指令创建了一个长等待时间依赖性链，然后创建了一个独立的链，试图欺骗CPU返回堆栈预测变量。

代码说明
使用FLUSH + RELOAD1将specpoline插入到配置文件上下文中，同一程序集文件还包含:buffer一个连续的缓冲区，它跨越256个不同的高速缓存行，每个高速缓存行由GAP-1行分隔开来，总共256*64*GAP字节。
GAP用于防止硬件预取。
随后是图形描述(每个索引紧接另一个)。
assembly - 为什么这种谱线在Kaby湖上不起作用？-LMLPHPtimings256个DWORD数组，每个条目保存访问F + R缓冲区中相应行所需的时间(以核心周期为单位)。flush一个小功能，可以触摸F + R缓冲区的每一页(带有存储，请确保COW在我们这边)并逐出指定的行。
“个人资料”
标准配置文件功能，可以很好地使用lfence+rdtsc+lence来分析F + R缓冲区中每一行的负载，并将结果存储在timings数组中。leak这是完成实际工作的函数，调用specpoline在推测路径中放置存储，在架构路径中调用profile函数。
;Flush the F+R lines
        call flush

        ;Unaligned stack, don't mind
        lea rax, [.profile]
        push rax
        call specpoline

        ;O.O 0
        ; o o o SPECULATIVE PATH
        ;0.0 O

        %ifdef SPEC_STORE
            mov DWORD [buffer], 241        ;Just a number
        %endif

        ud2                             ;Stop speculation

   .profile:
        ;Ll Ll
        ;  !  !  ARCHITECTURAL PATH
        ;Ll Ll

        ;Fill the timings array
        call profile
一个小的C程序用于“引导”测试工具。
运行测试
如果定义了ARCH_STORE，则代码使用预处理器有条件地将有条件地放置在体系结构路径中(实际上是在specpoline本身中)，如果定义了SPEC_STORE，则将预处理器有条件地放置在推测路径中。
两者都存储访问F + R缓冲区的第一行。
运行make run_spec和make run_arch将组装spec.asm和相应的符号，编译测试并运行它。
该测试显示了F + R缓冲区每一行的时序。
在体系结构路径中存储
 38    230    258    250    212    355    230    223    214    212    220    216    206    212    212    234
213    222    216    212    212    210   1279    222    226    301    258    217    208    212    208    212
208    208    208    216    210    212    214    213    211    213    254    216    210    224    211    209
258    212    214    224    220    227    222    224    208    212    212    210    210    224    213    213
207    212    254    224    209    326    225    216    216    224    214    210    208    222    213    236
234    208    210    222    228    223    208    210    220    212    258    223    210    218    210    218
210    218    212    214    208    209    209    225    206    208    206   1385    207    226    220    208
224    212    228    213    209    226    226    210    226    212    228    222    226    214    230    212
230    211    226    218    228    212    234    223    228    216    228    212    224    225    228    226
228    242    268    226    226    229    224    226    224    212    299    216    228    211    226    212
230    216    228    224    228    216    228    218    228    218    227    226    230    222    230    225
228    226    224    218    225    252    238    220    229   1298    228    216    228    208    230    225
226    224    226    210    238    209    234    224    226    255    230    226    230    206    227    209
226    224    228    226    223    246    234    226    227    228    230    216    228    211    238    216
228    222    226    227    226    240    236    225    226    212    226    226    226    223    228    224
228    224    229    214    224    226    224    218    229    238    234    226    225    240    236    210
存储在推测路径中
298    216    212    205    205   1286    206    206    208    251    204    206    206    208    208    208
206    206    230    204    206    208    208    208    210    206    202    208    206    204    256    208
206    208    203    206    206    206    206    206    208    209    209    256    202    204    206    210
252    208    216    206    204    206    252    232    218    208    210    206    206    206    212    206
206    206    206    242    207    209    246    206    206    208    210    208    204    208    206    204
204    204    206    210    206    208    208    232    230    208    204    210   1287    204    238    207
207    211    205    282    202    206    212    208    206    206    204    206    206    210    232    209
205    207    207    211    205    207    209    205    205    211    250    206    208    210    278    242
206    208    204    206    208    204    208    210    206    206    206    206    206    208    204    210
206    206    208    242    206    208    206    208    208    210    210    210    202    232    205    207
209    207    211    209    207    209    212    206    232    208    210    244    204    208    255    208
204    210    206    206    206   1383    209    209    205    209    205    246    206    210    208    208
206    206    204    204    208    246    206    206    204    234    207    244    206    206    208    206
208    206    206    206    206    212    204    208    208    202    208    208    208    208    206    208
250    208    214    206    206    206    206    208    203    279    230    206    206    210    242    209
209    205    211    213    207    207    209    207    207    211    205    203    207    209    209    207
我在构架路径中放置了一个商店来测试计时功能，似乎可以正常工作。
但是，我无法在推测路径中的商店中获得相同的结果。
为什么CPU不以推测方式执行存储？

1我承认，我从未真正花费时间来区分所有缓存分析技术。我希望我使用正确的名字。用FLUSH + RELOAD表示退出一组行，推测性地执行一些代码，然后记录访问每一条退出行的时间的过程。

最佳答案

您的“长条链”与那些经过微编码的x87指令相距很远。 fcos在SKL上为53-105微秒，周期吞吐量为50-130。因此，每个uop延迟大约1个周期，并且“仅”调度程序/预留站(RS)在SKL/KBL中有97个条目。同样，将后面的指令放入乱序的后端也可能是一个问题，因为微码接管了前端，并且需要某种机制来决定接下来要发出哪些指令，这可能取决于某些计算的结果。 (已知微码的数量与数据有关。)

如果您希望从充满未执行的uo的RS中获得最大的延迟，那么sqrtpd依赖链可能是您最好的选择。例如

    xorps  xmm0,xmm0                   ; avoid subnormals that might trigger FP assists
    times 40 sqrtsd xmm0, xmm0

    ; then make the store of the new ret addr dependent on that chain
    movd   ebx, xmm0
    ; and  ebx, 0            ; not needed, sqrt(0) = 0.0 = integer bit pattern 0
    mov [rsp+rbx], rax
    ret

自Nehalem以来，英特尔CPU借助分支顺序缓冲区(可对OoO状态(包括RAT以及可能包括RS)What exactly happens when a skylake CPU mispredicts a branch?进行快照)的分支未命中而得以快速恢复。 ，以便他们可以完全恢复到错误的预测，而不必等待错误的预测成为退休状态。
mov [rsp], rax可以在进入RS后立即执行，或者至少不依赖于sqrt dep链。只要存储转发能够产生该值，ret uop就可以执行并检查预测，并在sqrt dep链仍处于崩溃状态时检测到错误预测。 (ret是用于装载端口+端口6的1个微融合uop，此处是分支执行单元所在的端口。)

将sqrtsd dep链耦合到存储新的返回地址可防止ret执行早期的。在执行端口中执行ret uop =检查预测并检测是否存在错误预测。

(与Meltdown形成对比，“错误”路径一直保持运行，直到故障负载达到报废，并且您希望它尽快执行(只是不退出)。但是您通常希望将整个Meltdown攻击置于其他事物的阴影下， (例如TSX或specpoline)，在这种情况下，您将需要类似的内容，并且整个熔化都在此dep链的阴影下。然后Meltdown不需要自己的sqrtsd dep链。)

(在SKL上，vsqrtpd ymm仍然是1 uop，吞吐量比xmm差，但具有相同的延迟。因此，请使用sqrtsd，因为它的长度相同并且可能更节能。)

最佳情况下的延迟是15个周期，而SKL/KBL(https://agner.org/optimize)上的最坏情况是16个周期，因此从什么输入开始几乎没有关系。



如果XMM0保持次正规状态(例如，位模式是一个小整数)，则sqrtpd将使用微码辅助。 (fp_assist.any性能计数器)。即使结果正常，但输入也不正常。我使用以下循环在SKL上测试了这两种情况:
  pcmpeqd   xmm0,xmm0
  psrlq     xmm0, 61        ; or 31 for a subnormal input whose sqrt is normalized
  addpd     xmm0,xmm0       ; avoid domain-crossing vec-int -> vec-fp weirdness

  mov   ecx, 10000000
.loop:
    sqrtpd  xmm1, xmm0
    dec    ecx
    jnz   .loop

 mov eax,1
 int 0x80   ; sys_exit
perf stat -etask-clock,context-switches,cpu-migrations,page-faults,cycles,branches,instructions,uops_issued.any,uops_executed.thread,fp_assist.any对不正常的输入显示每次迭代1次协助，并发出951M uops(每次迭代约160个周期)。因此，我们可以得出结论，在这种情况下，针对sqrtpd的微码辅助大约需要95微秒，并且背对背发生时的吞吐成本大约为160个周期。

相对于输入= NaN(全1)发出的2000万次uops，每次迭代有4.5个周期。 (该循环运行10M sqrtpd uops和10M宏融合的dec/jcc uops。)

关于assembly - 为什么这种谱线在Kaby湖上不起作用？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/55542600/

10-11 18:41
Powered by LMLPHP ©2024 specpoline 0.044500