C/C++ 中的小型与相同类型的循环变量以提高性能

Question

假设我有一个较大的表单嵌套循环

long long i, j, k, i_end, j_end;
...
for (i = 0; i < i_end; i++) {
  j_bgn = get_j_bgn(i);
  for (j = j_bgn; j < j_end; j++) {
    ...
  }
}

有一些大的i_end 和j_end，比如i_end = j_end = 10000000000。如果我知道j_bgn 总是很小，甚至可能总是0 或1，那么为此使用较小的类型是否有益于性能，例如signed char j_bgn？或者，每次我们开始一个新的j 循环时，由于隐式转换为long long，这是否会带来经常性成本？

我想这有一个很小的影响，但我想知道这样做的“正确”/迂腐方式：要么 1）保持所有循环变量的类型相同（并使用可以冷却的最小类型所需的最大整数），或 2）独立选择每个循环变量的类型，使其尽可能小。

编辑

从我看到的 cmets/answers 我需要提供更多信息：

• 我有时想要，有时不想使用这些变量（例如j）进行索引。为什么这很重要（只要我确保使用足够大的类型来覆盖我的可用内存）？
• 在我的实际代码中，我使用size_t（或ssize_t）之类的东西，例如j，j_end。在现代硬件上，这是 64 位。

我认为使用小于 32 位的类型是不值得的，但是对于 j_bgn 使用 32 位类型而不是也使用 64 位类型可能仍然有益（因为我确实需要 @987654338 @ 和j_end)?

Answer 1

这听起来像是在<cstdint>（用于 C++）或<stdint.h>（用于 C）中定义的“快速”数据类型的实际用例。

您可以使用int_fast8_t、int_fast16_t、int_fast32_t 或int_fast64_t 或它们的无符号吊坠，以获得至少8、16、32 或64 字节大的最快整数类型。

我想如果你想真正迂腐，你应该选择这些，让编译器选择最快的选项。

Answer 2

如果整数比寄存器的宽度更宽或更小，许多平台需要一些额外的操作。 （不过，大多数 64 位平台可以像处理 64 位一样高效地处理 32 位整数。）

示例（使用空的 asm 语句来停止循环优化）：

void lfoo(long long int loops)
{
    for(long long int i = 0; i < loops; i++) asm("");
}

void foo(int loops)
{
    for(int i = 0; i < loops; i++) asm("");
}

void bar(short int loops)
{
    for(short int i = 0; i < loops; i++) asm("");
}

void zoo(char loops)
{
    for(char i = 0; i < loops; i++) asm("");
}

以及生成的旧 32 位 ARM Cortex 处理器的代码，没有 ARMv6 符号扩展指令，这使得 short 的糟糕程度稍低（Godbolt compiler explorer, gcc8.2 默认选项，-O3 没有 -march= 或 -mcpu=cortex-...）

lfoo:
        cmp     r0, #1
        sbcs    r3, r1, #0
        bxlt    lr
        mov     r2, #0
        mov     r3, #0
.L3:
        adds    r2, r2, #1
        adc     r3, r3, #0        @@ long long takes 2 registers, obviously bad
        cmp     r1, r3
        cmpeq   r0, r2            @@ and also to compare
        bne     .L3
        bx      lr

foo:
        cmp     r0, #0
        bxle    lr                @ return if loops==0 (predicate condition)
        mov     r3, #0            @ i = 0
.L8:                              @ do {
        add     r3, r3, #1          @ i++  (32-bit)
        cmp     r0, r3             
        bne     .L8               @ } while(loops != i);
        bx      lr                @ return

bar:
        cmp     r0, #0
        bxle    lr
        mov     r2, #0
.L12:                            @ do {
        add     r2, r2, #1          @ i++ (32-bit)
        lsl     r3, r2, #16         @ i <<= 16
        asr     r3, r3, #16         @ i >>= 16  (sign extend i from 16 to 32)
        cmp     r0, r3
        bgt     .L12             @ }while(loops > i)
        bx      lr
                @@ gcc -mcpu=cortex-a15 for example uses
                @@  sxth    r2, r3

zoo:
        cmp     r0, #0
        bxeq    lr
        mov     r3, #0
.L16:
        add     r3, r3, #1
        and     r2, r3, #255     @ truncation to unsigned char is cheap
        cmp     r0, r2           @ but not free
        bhi     .L16
        bx      lr

如您所见，最有效的是 32 位整数，因为它们的大小与处理器寄存器相同（函数 foo）。