您可以使用C内联汇编来对齐说明吗？ （没有编译器优化）

Question

我必须进行一个大学项目，我们必须使用缓存优化来提高给定代码的性能，但是我们不得使用编译器优化来实现它。

我阅读的参考书目的想法之一是将基本块的开始与线路缓存大小保持一致。但是，您可以做类似的事情：

asm(".align 64;")
for(int i = 0; i<N; i++)
... (whole basic block)

为了实现我的需求吗？我不知道是否有可能在教学对准方面这样做。我已经看到了一些技巧，例如 _mm_malloc 以实现数据对齐，但没有用于说明。有人可以给我一些问题吗？

Answer 1

tl：dr：这可能不是很有用（因为带有UOP缓存的现代X86通常不在乎代码对齐 ¹ ），但是在 do {} while（） loop ，可以直接使用相同的布局编译到ASM ，在循环的实际顶部之前，没有任何循环设置（序言）指令。 （向后分支的目标）。

一般而言， asm（“ foo”）; 在函数内部，但在调试模式（ -O0 默认值，又称优化）每个语句（包括 asm （）; ）按源顺序编译到ASM的单独块。因此，您的情况实际上不需要扩展 asm（“。p2align 4” ::::“内存”）即可订购ASM语句WRT。内存操作。 （同样在最近的GCC中，内存clobber对具有非空模板字符串字符串的基本ASM隐含）。在最坏的情况下，启用了填充物可能会毫无用处而损害性能，但与 asm（）的大多数用途不同。

---

这实际上如何编译

这并不能完全奏效； loop在 的 c 。尤其是在使用（a; b; c）循环的时，在语句 a 中使用一些先前的初始化！您当然可以在源中撤出，但是GCC的 -O0 编译和和 loops 的 是用 jmp 到底部的条件。

但是， JMP 仅是一个小（2字节）指令，因此在此之前对齐将使循环的顶部附近 可能的开始获取块，如果那是瓶颈，它仍然会获得大部分利益。 （或接近一组新的UOP-CACHE系列Sandybridge-family x86，其中32字节的边界是相关的。甚至是64字节I-CACHE线路，尽管这很少相关，并且可能导致很多nop被执行to reach that boundary. And bloated code size.)

void foo(register int *p)
{
    // always use .p2align n or .balign 1<<n so it's unambiguous across targets like MacOS vs. Linux, never .align
    asm("   .p2align 5 # from inline asm");
    for (register int *endp = p + 102400; p<endp ; p++) {
        *p += 123;
    }
}

Compiles as follows on the

# GCC11.3 -O0 (the default with no options, except for -masm=intel added by Godbolt)
foo:
        push    rbp
        mov     rbp, rsp
        push    rbx                        # GCC stupidly picks a call-preserved reg it has to save
        mov     rax, rdi
           .p2align 5 # from inline asm
        lea     rbx, [rax+409600]          # endp = p+102400
        jmp     .L2                        # jump to the p<endp condition before the first iteration
## The actual top of the loop.  9 bytes past the alignment boundary
.L3:                                       # do{
        mov     edx, DWORD PTR [rax]
        add     edx, 123
        mov     DWORD PTR [rax], edx         # A memory destination add dword [rax], 123  would be 2 uops for the front-end (fused-domain) on Intel, vs. 3 for 3 separate instructions.
        add     rax, 4                       # p++
.L2:
        cmp     rax, rbx
        jb      .L3                        # }while(p<endp)
        nop
        nop                                # These aren't for alignment, IDK what this is for.
        mov     rbx, QWORD PTR [rbp-8]     # restore RBX
        leave                              # and restore RBP / tear down stack frame
        ret

该循环长5个UOP（假设CMP/JCC的宏观融合），因此，如果一切顺利，可以在Ice Lake或Zen上以1个周期运行。 （每个周期的负载 /商店1 dword的负载不多，并不多，因此应该跟上大型数组，即使它不适合L3 Cahce。）或也许有点一点由于循环缓冲效应更糟。

如果您在Godbolt上使用“二进制”输出模式，则可以看到 lea rbx，[rax+409600] 是7字节的指令，而 jmp .l2 是2字节，循环顶部的地址为 0x401149 ，即在16个字节fetch-block中进行9个字节，在该大小的CPU上。我以32对齐，所以与该块关联的第一个UOP缓存线中只浪费了2个UOP，因此我们在32字节块中仍然相对较好。

（Godbolt“二进制”模式将其编译并链接到可执行文件中，并在此上运行 objdump -d 。这也使我们可以看到 .p2align 指令>指令扩展为NOP指令某些宽度，或一个以上的宽度，如果必须跳过11个字节以上，则X86-64的默认最大宽度宽度。 ，因此在功能中以及对I-Cache足迹的巨大对齐是一件坏事。）

一个相当明显的转换使LEA在 .p2align 。（如果您很好奇，请参见所有这些源版本的Godbolt链接中的ASM）。

    register int *endp = p + 102400;
    asm("   .p2align 5 # from inline asm");
    for ( ; p < endp ; p++) {
        *p += 123;
    }

或 while（p＆lt; endp）{...; P ++} 也可以做到这一点。 ASM循环的顶部变为以下内容，在循环条件下只有2字节 JMP 。因此，这是相当不错的，并获得了大部分好处。

        lea     rbx, [rax+409600]
           .p2align 5 # from inline asm
        jmp     .L5                       # 2-byte instruction
.L6:

可以使用来实现同一操作（foo = bar，asm（“。p2align 4）; p＆lt; endp; p ++）。但是，如果您在第一部分中声明一个变量 运算符无法让您在单独的语句中偷偷摸摸。

对于语句的，逗号 。

    register int *endp = p + 102400;
    asm("   .p2align 5 # from inline asm");
    do {
        *p += 123;
        p++;
    }while(p < endp);

        lea     rbx, [rax+409600]
           .p2align 5 # from inline asm
.L8:                                     # do{
        mov     edx, DWORD PTR [rax]
        add     edx, 123
        mov     DWORD PTR [rax], edx
        add     rax, 4
        cmp     rax, rbx
        jb      .L8                      # while(p<endp)

代码> 为您放置 的循环

。非零尺寸，no p == endp 在第一次迭代之前运行。 ）返回; 在循环之前，请在 and and 上放置 启用具有优化的循环，如果它无法证明它始终运行至少一次迭代。

  if(n!=0) {
      register int *endp = p + n;
      asm (".p2align 4");
      do {
          ...
      }while(p!=endp); 
  }

让GCC为您执行此操作： -falign-loops = 16 在 -O0

gcc -O2 enables eNables - falign-loops = 16：11：8 或类似的东西（如果跳过少于11个字节，则按16对齐，否则按8对齐）。这就是为什么GCC使用两个 .p2align 指令的序列，对第一个序列限制了限制（请参阅气体手册）。

        .p2align 4,,10            # what GCC does on its own
        .p2align 3

但使用 -falign-loops = 16 在 -O0 上什么都不做。 GCC -O0似乎不知道循环是什么。：p

，gcc do 尊重 -falign-labels 即使在 -O0 。但是不幸的是，这适用于所有标签，包括内部循环内的循环入口点。 godbolt 。

# gcc -O0 -falign-labels=16
## from compiling endp=...; asm(); while() {}
        lea     rbx, [rax+409600]              # endp = ...
           .p2align 5 # from inline asm
        jmp     .L5
        .p2align 4                         # from GCC itself, pads another 14 bytes to an odd multiple of 16 (if you didn't remove the manual .p2align 5)
.L6:
        mov     edx, DWORD PTR [rax]
        add     edx, 123
        mov     DWORD PTR [rax], edx
        add     rax, 4
        .p2align 4                         # from GCC itself: one 5-byte NOP in this particular case
.L5:
        cmp     rax, rbx
        jb      .L6

在内部最高循环中放置NOP比在现代X86 CPU上的开始要差。

您没有 do {} while（）循环没有这个问题那里。

（我使用如何从gcc/clang组装中删除“噪声”输出？对于无需过滤指令的编译选项，其中包括 .p2align ，如果我只想查看Inline ASM去的位置，我可以使用 过滤指令可见。

---

ASM（“ nop #hi mom”）可以通过 在Inline ASM中，具有输入/输出约束。 （，但真的不做； ）

---

脚注1：代码对齐对现代X86无济于事，可能会对其他人有帮助，

即使您确实确实使后退分支的目标保持一致（相反，也不太可能有帮助 不仅仅是一些循环序言）；现代X86 CPU带有UOP缓存（Sandybridge-Family and Zen-Family）和Loop Buffer（Nehalem和后来的Intel）不太在乎环路对齐。

它可以对较旧的X86 CPU或其他一些ISA有帮助；只有X86很难解码，以至于UOP缓存是一件事情（您实际上并未指定X86，但是目前大多数人在台式机/笔记本电脑中使用X86 CPU，所以我假设。）

） ）分支目标对齐的主要原因有助于（尤其是循环的顶部），是当CPU获取一个16字节的块时，包括 该块将在之后进行，因此将要运行另一个迭代的循环主体的一部分。 （在该提取周期浪费分支目标之前的字节）。

但是，不一致的不一致的最坏情况（除非其他怪异的效果）只是您要花1个额外的前端提取周期，以获取循环主体中的更多说明。 （例如，如果循环的顶部的地址为 0xf 结尾字节在末尾。）可能是 cdq 之类的单字节指令，但是管道通常是宽或更多的4个指令。

（或在Intel P6早期的早期几天中，在提取，预码（长度查找）和解码之间有缓冲区之前的几天。但是，直到Nehalem的循环缓冲液可以回收一个小环（UOP），以回收一个较小的循环（一个二十二个UOPS），并将其添加到sandybridge添加了多个功能，这些瓶子仍然很大。经常。 href =“ https://www.agner.org/optimize/” rel =“ nofollow noreferrer”> https://www.agner.org/optimize/ 尤其是Agner的Microarch PDF

。当前端（指令获取/解码）带宽是一个问题时最慢的瓶颈，直到缓存缺乏负载后才能等到以后的说明进行填写和解码​​。 （请参阅 this ，尤其是 href =“ https://www.lighterra.com/papers/modernmicropropersess/” rel =“ nofollow noreferrer”>现代微处理器90分钟的指南！。。

）如果microcode更新禁用了循环缓冲区（LSD），因此在32字节边界上划分的小环形主体可以每2个周期（从2个单独的缓存线中获取UOPS）以最佳1迭代运行。或再次在Skylake上，以这种方式调整代码对齐方式可以帮助避免JCC杂音（如果您不能通过 -wa，-mbranches-within，则可以使代码的一部分从旧版解码而不是UOP缓存运行） -32b-boundaries 使汇编器围绕它工作。 （我如何减轻英特尔JCC杂音对海湾合作委员会的影响？）。这些问题特定于Skylake衍生的微体系结构，并固定在Ice Lake中。

当然，反优化的调试模式代码是如此肿，以至于即使是紧密的循环也不太可能少于8个UOPS，因此32个字节边界的问题可能不会受到太大伤害。但是，如果您通过在本地vars上使用 register 避免存储/重新加载延迟瓶颈（是的（是的，这在debug build build holding 中都会做，否则它是毫无意义的 ^{1 ），如果内部循环最终在内部或有条件的分支底部或位于jcc沟中，则在Skylake CPU上获得所有这些效率低下的说明的前端瓶颈很可能会受到Skylake CPU的影响。循环结束。}

无论如何，正如Eric评论的那样，您的作业可能更多地是关于数据访问模式，并且可能是布局和对齐。据推测，由于L2或L3高速缓存的错过是唯一足够慢的东西，因此涉及大量内存的小环路，而不是在禁用了优化的建筑物中更像是瓶颈。也许在某些情况下L1D，如果您设法让编译器使不易rable ASM进行调试模式，或者如果负载使用延迟（不仅仅是吞吐量）是关键路径的一部分。

脚注2： -O0 是愚蠢的，但是注册int i 可以帮助

查看
c循环优化帮助最终分配（具有编译器）禁用的优化） re：为调试模式优化源代码或以正常用例的方式进行基准测试是多么愚蠢。但是，还提到了某些对于这种情况（与普通构建不同）更快的事情，例如在单个语句或表达中做更多的事情，因为编译器不会在跨语句中保留寄存器中的内容。

（另请参见为什么clang clang clang使用-O0产生效率低下的ASM（对于此简单的浮点总和）？以获取详细信息）

除 register 变量;该过时的关键字仍然可以使用GCC（但不叮当）来实现不可优化的构建。在最近的C ++版本中，它已正式弃用甚至删除，但尚未c。

您绝对想使用 Int i 让调试构建将其保存在寄存器中，并像手工编写的ASM一样写下您的C。例如，在适当的情况下，使用指针增量代替 arr [i] ，特别是对于没有索引地址模式的ISA。

寄存器变量在您的内部循环中最重要，并且在禁用优化后，编译器可能并不是很聪明，因为决定哪个 register var实际上是寄存器，如果登记量已耗尽。 （X86-64除堆栈指针以外的15个整数REG，并且调试构建将将其中一个用于帧指针。）

尤其是对于更改内部循环的变量，以避免存储/重新加载潜伏期瓶颈，例如（注册int i = 1000000; - i;）; 可能在每个时钟运行1次迭代，而没有 register> register 在现代x86-- 64 CPU喜欢Skylake。

如果使用整数变量作为数组索引，请将其 intptr_t 或 uintptr_t （ #include＆lt; stdint.h＆gt; ）编译器不必从32位 int 换成64位指针宽度以用于寻址模式。

（除非您要编译Aarch64，否则其通话模式为64位寄存器和32位寄存器，执行符号或零扩展名，并且忽略了窄整数中的高垃圾。这完全是因为这是编译器可以' t总是优化。 “ rel =“ nofollow noreferrer”>允许编译器扩大整数循环变量或转换为指针增量。）

也很松散相关：在Intel Sandybridge-family CPU中为管道的程序进行除去有意地通过缓存效应使事情缓慢地使事情变得缓慢，相反。可能不是很适合，idk您的问题是什么样的。