最小操作码大小 x86-64 strlen 实现

Question

我正在研究我的代码高尔夫/二进制可执行文件的最小操作码大小x86-64 strlen实现，该实现不应该超过某个大小（为了简单起见，请考虑演示场景）。
一般想法来自这里，大小优化想法来自这里和这里。

输入字符串地址在rdi ，最大长度不应大于Int32

xor   eax,eax ; 2 bytes
or    ecx,-1  ; 3 bytes
repne scasb   ; 2 bytes
not   ecx     ; 2 bytes
dec   ecx     ; 2 bytes

最终结果在ecx中，总共11 个字节。

问题是关于将ecx设置为-1

选项 1 已经说明

or ecx,-1 ; 3 bytes

选项 2

lea ecx,[rax-1] ; 3 bytes 

选项 3

stc         ; 1 byte
sbb ecx,ecx ; 2 bytes

选项 4 ，可能是最慢的一个

push -1 ; 2 bytes
pop rcx ; 1 byte

我的理解是：
选项 1 依赖于以前的ecx值
选项 2 依赖于先前的rax值
选项 3 我不确定它是否依赖于以前的ecx值？
选项 4 是最慢的一个？

这里有明显的赢家吗？
标准是保持操作码的大小尽可能小，并明智地选择最佳的一种。
我完全知道有使用现代 cpu 指令的实现，但这种遗留方法似乎是最小的。

Answer 1

对于 hacky 足够好的版本，我们知道rdi有一个有效的地址。 edi很可能不是一个小整数，因此是 2 字节mov ecx, edi 。 但这并不安全，因为 RDI 可能刚好超过 4GiB 边界，因此很难证明它是安全的。 除非您使用像 x32 这样的 ILP32 ABI，否则所有指针都低于 4GiB 标记。

因此，您可能需要使用 push rdi / pop rcx 复制完整的 RDI，每个 1 字节。 但这为短字符串启动增加了额外的延迟。 如果没有长度大于起始地址的字符串，那应该是安全的。 （但是，如果您有任何庞大的数组，这对于 .data、.bss 或 .rodata 中的静态存储是合理的；例如，Linux 非 PIE 可执行文件的加载速度约为0x401000 = 1<<22。）

如果您只想让 rdi 指向终止的0字节，而不是实际需要计数，这很好。 或者，如果您在另一个寄存器中有起始指针，那么您可以执行sub edi, edx或其他操作，并以这种方式获取长度，而不是处理rcx结果。 （如果您知道结果适合 32 位，则不需要sub rdi, rdx因为您知道无论如何它的高位都是零。并且高输入位不会影响加/减的低输出位；进位从左到右传播。）

对于已知小于 255 字节的字符串，您可以使用mov cl, -1 （2 字节）。 这使得rcx至少为 0xFF，并且更高，具体取决于其中剩余的高垃圾。 （当读取 RCX 时，这在 Nehalem 和更早版本上有一个部分 reg 停顿，否则只是对旧 RCX 的依赖）。 无论如何，然后mov al, -2 / sub al, cl得到一个 8 位整数的长度。 这可能有用也可能没用。

根据调用者的不同， rcx可能已经持有一个指针值，在这种情况下，如果您可以使用指针减法，您可以保持它不变。

---

在您提出的选项中

lea ecx,[rax-1]非常好，因为你只是异或归零eax ，它是一个便宜的 1 uop 指令，具有 1 个周期延迟，可以在所有主流 CPU 的多个执行端口上运行。

当您已经有另一个具有已知常量值的寄存器时，尤其是异或零值的寄存器时，3 字节lea几乎总是创建常量的最有效的 3 字节方式，如果它有效的话。 （请参阅有效地将 CPU 寄存器中的所有位设置为 1 ）。

---

我完全知道有使用现代 cpu 指令的实现，但这种遗留方法似乎是最小的。

是的， repne scasb非常紧凑。 在典型的英特尔 CPU 上，它的启动开销可能大约为15 个周期，根据Agner Fog 的说法，它发出 >=6n uops ，吞吐量 >= 2n 个周期，其中n是计数（即它比较的每字节 2 个周期） long 比较，其中隐藏了启动开销），因此它使lea的成本相形见绌。

对ecx有错误依赖的东西可能会延迟它的启动，所以你肯定想要lea 。

repne scasb可能足够快，无论你在做什么，但它比pcmpeqb / pmovmsbk / cmp慢。 对于短的定长字符串，当长度为 4 或 8 个字节（包括终止的 0）时整数cmp / jne非常好，假设您可以安全地重读您的字符串，即您不必担心""在页面的末尾。 但是，此方法的开销随字符串长度而变化。 例如，对于字符串长度 = 7，您可以执行 4、2 和 1 个操作数大小，或者您可以执行两个重叠 1 个字节的双字比较。 像cmp dword [rdi], first_4_bytes / jne ; cmp dword [rdi+3], last_4_bytes / jne 。

---

有关 LEA 的更多详细信息

在 Sandybridge 系列 CPU 上， lea可以在与它相同的周期内被分派到一个执行单元，并且xor -0 被发送到乱序 CPU 内核中。 xor -zeroing 在问题/重命名阶段处理，因此 uop 以“已执行”状态进入 ROB。 指令不可能永远等待 RAX。 （除非在 xor 和lea之间发生中断，但即便如此，我认为在恢复 RAX 之后和lea可以执行之前会有一个序列化指令，所以它不会被卡住等待。）

简单的lea可以在 SnB 上的端口 0 或端口 1 上运行，或者在 Skylake 上的端口 1/端口 5 上运行（每个时钟吞吐量 2 个，但有时在不同的 SnB 系列 CPU 上有不同的端口）。 这是 1 个周期的延迟，因此很难做得更好。

使用可以在任何 ALU 端口上运行的mov ecx, -1 （5 字节），您不太可能看到任何加速。

在 AMD Ryzen 上，64 位模式下的lea r32, [m]被视为只能在 2 个端口上运行的“慢”LEA，并且延迟为 2c 而不是 1。更糟糕的是，Ryzen 并没有消除异或归零.

---

您所做的微基准测试仅测量没有错误依赖项的版本的吞吐量，而不是延迟。 这通常是一个有用的衡量标准，您确实得到了正确的答案，即lea是最佳选择。

纯吞吐量是否准确反映了您的实际用例是另一回事。 如果字符串比较作为长或循环携带的数据依赖链的一部分而不被jcc破坏，则您实际上可能依赖于延迟，而不是吞吐量，以提供分支预测 + 推测执行。 （但无分支代码通常更大，所以这不太可能）。

stc / sbb ecx,ecx很有趣，但只有 AMD CPU 将sbb视为破坏依赖性（仅取决于 CF，而不是整数寄存器）。 在 Intel Haswell 及更早版本上， sbb是 2 uop 指令（因为它有 3 个输入：2 GP 整数 + 标志）。 它有 2c 的延迟，这就是它表现如此糟糕的原因。 （延迟是一个循环携带的 dep 链。）

---

缩短序列的其他部分

根据你在做什么，你也可以使用strlen+2 ，但抵消另一个常量或其他东西。 dec ecx在 32 位代码中只有 1 个字节，但 x86-64 没有短格式的inc/dec指令。 所以 not / dec 在 64 位代码中没有那么酷。

在repne scas ，你有ecx = -len - 2 （如果你从ecx = -1开始），而not给你-x-1 （即+len + 2 - 1 ）。

 ; eax = 0
 ; ecx = -1
repne scasb      ; ecx = -len - 2
sub   eax, ecx   ; eax = +len + 2

Answer 2

我在 Intel Core i7 4850HQ Haswell 2,3 GHz 上做了一些基准测试，发布版本没有附加调试器。 在每个循环中，我测量 1000 个 asm 指令序列并重复 1000 万次以求平均结果。

我已经制作了用于重复 asm 指令 100 次的宏。

#define lea100 asm{xor   eax,eax};asm { lea ecx,[rax-1] }; // <== Copy pasted 100times
#define or100 asm{xor   eax,eax};asm { or ecx,-1 }; // <== Copy pasted 100times
#define sbb100 asm{xor   eax,eax};asm { stc };asm{sbb ecx,ecx}; // <== Copy pasted 100times
#define stack100 asm ("xor %eax,%eax;.byte 0x6A; .byte 0xFF ;pop %rcx;"); // <== Copy pasted 100times

使用适用于 MacOS 的内联 asm 测试 C 代码

#include <stdio.h>
#include <CoreServices/CoreServices.h>
#include <mach/mach.h>
#include <mach/mach_time.h>
int main(int argc, const char * argv[]) {
    uint64_t        start;
    uint64_t        end;
    uint64_t        elapsed;
    Nanoseconds     elapsedNano;

    uint64_t sum = 0;
    for (int i = 0; i < 10000000 ; i++) {

// this will become
// call       imp___stubs__mach_absolute_time  
// mov        r14, rax
    start = mach_absolute_time();

//10x lea100 for example for total 1000 

// call       imp___stubs__mach_absolute_time
// sub        rax, r14
    end = mach_absolute_time();

    elapsed = end - start;
    elapsedNano = AbsoluteToNanoseconds( *(AbsoluteTime *) &elapsed );
    uint64_t nano = * (uint64_t *) &elapsedNano;
        sum += nano;
    }
    printf("%f\n",sum/10000000.0);
    return 0;
}

结果

xor eax,eax
lea ecx,[rax-1]

205-216 纳秒

xor eax,eax
or ecx,-1

321-355 纳秒

xor eax,eax
push -1 
pop rcx 

322-359 纳秒

xor eax,eax
stc     
sbb ecx,ecx

612-692 纳秒